Recent Changes - Search:

My Projects

Courses

Writings

Source Code

Social Networks

Live Traffic !

Évolution 9 : Les nombres décimaux

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

<< Évolution 8 : Autres boucles for | Évolution 9 : Les nombres décimaux | Évolution 10 : Les entrées clavier >>

Nous allons mettre en place un tout nouveau type de variable : les nombres décimaux ! Les noms des variables devront commencer par un 'd' minuscule. Le lexème decimal sera de la forme nombre.nombre.

Évolution 9 du langage :

  1. <affectation> ::= <affectation> | variable_decimale "=" <expression_arithmetique> ";"
  2.  
  3. <expression_arithmetique> ::= <expression_arithmetique> | variable_decimale | decimal

Nous allons mettre à jour l'analyseur lexical pour intégrer les deux nouveaux lexèmes (variable_decimale et decimal) :

lexique_simple.lex
  1. %{
  2.  
  3. #include "simple.h"
  4. unsigned int lineno=1;
  5. bool error_lexical=false;
  6.  
  7. /* definition de la fonction de concatenation pour les chaines de texte */
  8. void* concat(char*,char*);
  9.  
  10. %}
  11.  
  12. %option noyywrap
  13.  
  14. entier 0|[1-9][[:digit:]]*
  15. decimal {entier}\.{entier}
  16. variable_booleenne b(_|[[:alnum:]])*
  17. variable_entiere e(_|[[:alnum:]])*
  18. variable_decimale d(_|[[:alnum:]])*
  19. variable_texte t(_|[[:alnum:]])*
  20.  
  21. /* regex de commentaire d'une seule ligne */
  22. commentaire ((\/\/|#).*)
  23.  
  24. /* pour les commentaires de plusieurs lignes, on declare nos deux lexemes en tant que conditions de demarrage exclusives (%x) dans Flex */
  25. %x  commentaire_1
  26. %x  commentaire_2
  27.  
  28. /* chaine de caractere */
  29. %x  chaine
  30.  
  31. %%
  32.  
  33. "/*"    {
  34.             /* un marqueur de debut de commentaire trouve -> on lui dit que le lexeme commentaire_1 commence */
  35.             BEGIN(commentaire_1);
  36.             printf("Commentaire detecte en ligne %i\n",lineno);
  37.         }
  38.  
  39. <commentaire_1>"\n"     {
  40.                             /* si on trouve des retours chariots et que la condition de demarrage est commentaire_1, alors on incremente la variable lineno. sans cela, on serait en decalage pour la suite de l'analyse */
  41.                             lineno++;
  42.                         }
  43.  
  44. <commentaire_1>"*"+"/"      {
  45.                                 /* si on au moins une fois "*" suivi de "/" et que la condition de demarrage est commentaire_1, alors on lui dit que le lexeme commentaire_1 est fini */
  46.                                 BEGIN(INITIAL);
  47.                                 printf("Fin du commentaire en ligne %i\n",lineno);
  48.                                 return TOK_COMMENT;
  49.                             }
  50.  
  51. <commentaire_1>.    {/* les autres caracteres suivants la conditions de demarrage sont absorbes par l'analyse est donc ingores */}
  52.  
  53. "<!--"      {
  54.                 BEGIN(commentaire_2);
  55.                 printf("Commentaire detecte en ligne %i\n",lineno);
  56.             }
  57. <commentaire_2>"\n"         {lineno++;}
  58. <commentaire_2>"-"+"-"+">"  {
  59.                                 BEGIN(INITIAL);
  60.                                 printf("Fin du commentaire en ligne %i\n",lineno);
  61.                                 return TOK_COMMENT;
  62.                             }
  63. <commentaire_2>.            {}
  64.  
  65. "\""         {
  66.                 /* debut de la chaine de texte (premier guillemet) */
  67.                 BEGIN(chaine);
  68.                 yylval.texte=malloc(sizeof(char)*strlen(yytext));
  69.                 if(yylval.texte==NULL){
  70.                     fprintf(stderr,"\tERREUR : Probleme de memoire sur une chaine texte a la ligne %i !\n",lineno);
  71.                     exit(-1);
  72.                 }
  73.                 yylval.texte=strdup(yytext);
  74.                 printf("Chaine de texte detectee en ligne %i\n",lineno);
  75.             }
  76.  
  77. <chaine>"\n"    {
  78.                     /* on prend en compte les sauts de ligne que l'on traduira par "\n" */
  79.                     lineno++;
  80.                     yylval.texte=(char*)concat(yylval.texte,"\\n");
  81.                     if(yylval.texte==NULL){
  82.                         fprintf(stderr,"\tERREUR : Probleme de memoire sur une chaine texte a la ligne %i !\n",lineno);
  83.                         exit(-1);
  84.                     }
  85.                 }
  86.  
  87. <chaine>"\t"    {
  88.                     /* on prend en compte les tabulations que l'on traduira par "\t" */
  89.                     yylval.texte=(char*)concat(yylval.texte,"\\t");
  90.                     if(yylval.texte==NULL){
  91.                         fprintf(stderr,"\tERREUR : Probleme de memoire sur une chaine texte a la ligne %i !\n",lineno);
  92.                         exit(-1);
  93.                     }
  94.                 }
  95.  
  96. <chaine>"\\\""    {
  97.                     /* pour echapper le guillemet dans la chaine \" */
  98.                     yylval.texte=(char*)concat(yylval.texte,yytext);
  99.                     if(yylval.texte==NULL){
  100.                         fprintf(stderr,"\tERREUR : Probleme de memoire sur une chaine texte a la ligne %i !\n",lineno);
  101.                         exit(-1);
  102.                     }
  103.                 }
  104.  
  105. <chaine>"\""     {
  106.                     /* fin de la chaine (deuxieme guillemet non echappe) */
  107.                     BEGIN(INITIAL);
  108.                     yylval.texte=(char*)concat(yylval.texte,yytext);
  109.                     if(yylval.texte==NULL){
  110.                         fprintf(stderr,"\tERREUR : Probleme de memoire sur une chaine texte a la ligne %i !\n",lineno);
  111.                         exit(-1);
  112.                     }
  113.                     printf("Fin de la chaine en ligne %i\n",lineno);
  114.                     return TOK_TEXTE;
  115.                 }
  116.  
  117. <chaine>.  {
  118.                 /* les caracteres de la chaine */
  119.                 yylval.texte=(char*)concat(yylval.texte,yytext);
  120.                 if(yylval.texte==NULL){
  121.                         fprintf(stderr,"\tERREUR : Probleme de memoire sur une chaine texte a la ligne %i !\n",lineno);
  122.                         exit(-1);
  123.                 }
  124.             }
  125.  
  126. {decimal} {
  127.     sscanf(yytext, "%lf", &yylval.decimal);
  128.     return TOK_DECIMAL;
  129. }
  130.  
  131. {entier} {
  132.     sscanf(yytext, "%ld", &yylval.entier);
  133.     return TOK_ENTIER;
  134. }
  135.  
  136. "si"    {return TOK_SI;}
  137.  
  138. "alors" {return TOK_ALORS;}
  139.  
  140. "sinon" {return TOK_SINON;}
  141.  
  142. "++"    {return TOK_INCREMENTATION;}
  143.  
  144. "--"    {return TOK_DECREMENTATION;}
  145.  
  146. "+="    {return TOK_AFFECT_PLUS;}
  147.  
  148. "-="    {return TOK_AFFECT_MOINS;}
  149.  
  150. "*="    {return TOK_AFFECT_MUL;}
  151.  
  152. "/="    {return TOK_AFFECT_DIV;}
  153.  
  154. "%="    {return TOK_AFFECT_MOD;}
  155.  
  156. "&="    {return TOK_AFFECT_ET;}
  157.  
  158. "|="    {return TOK_AFFECT_OU;}
  159.  
  160. "egal a"|"equivalent a"|"=="        {return TOK_EQU;}
  161.  
  162. "different de"|"!="|"<>"            {return TOK_DIFF;}
  163.  
  164. "superieur a"|"plus grand que"|">"  {return TOK_SUP;}
  165.  
  166. "inferieur a"|"plus petit que"|"<"  {return TOK_INF;}
  167.  
  168. "superieur ou egal a"|">="          {return TOK_SUPEQU;}
  169.  
  170. "inferieur ou egal a"|"<="          {return TOK_INFEQU;}
  171.  
  172. "compris dans"|"dans"               {return TOK_IN;}
  173.  
  174. "afficher"      {return TOK_AFFICHER;}
  175.  
  176. "supprimer"     {return TOK_SUPPR;}
  177.  
  178. "faire"         {return TOK_FAIRE;}
  179.  
  180. "x"             {return TOK_CROIX;}
  181.  
  182. "="             {return TOK_AFFECT;}
  183.  
  184. "+"             {return TOK_PLUS;}
  185.  
  186. "-"             {return TOK_MOINS;}
  187.  
  188. "*"             {return TOK_MUL;}
  189.  
  190. "/"             {return TOK_DIV;}
  191.  
  192. "%"             {return TOK_MOD;}
  193.  
  194. "^"             {return TOK_PUISSANCE;}
  195.  
  196. "("             {return TOK_PARG;}
  197.  
  198. ")"             {return TOK_PARD;}
  199.  
  200. "["             {return TOK_CROG;}
  201.  
  202. "]"             {return TOK_CROD;}
  203.  
  204. "?"             {return TOK_POINT_INTERROGATION;}
  205.  
  206. ":"             {return TOK_DOUBLE_POINT;}
  207.  
  208. "et"            {return TOK_ET;}
  209.  
  210. "ou"            {return TOK_OU;}
  211.  
  212. "non"|"!"           {return TOK_NON;}
  213.  
  214. ";"             {return TOK_FINSTR;}
  215.  
  216. "vrai"          {return TOK_VRAI;}
  217.  
  218. "faux"          {return TOK_FAUX;}
  219.  
  220. "\n"            {lineno++;}
  221.  
  222. {variable_booleenne} {
  223.     yylval.texte = yytext;
  224.     return TOK_VARB;
  225. }
  226.  
  227.  
  228. {variable_entiere} {
  229.     yylval.texte = yytext;
  230.     return TOK_VARE;
  231. }
  232.  
  233. {variable_decimale} {
  234.     yylval.texte = yytext;
  235.     return TOK_VARD;
  236. }
  237.  
  238. {variable_texte} {
  239.     yylval.texte = yytext;
  240.     return TOK_VART;
  241. }
  242.  
  243. {commentaire}   {
  244.     printf("Commentaire detecte en ligne %i\n",lineno);
  245.     printf("Fin du commentaire en ligne %i\n",lineno);
  246.     return TOK_COMMENT;
  247. }
  248.  
  249. " "|"\t" {}
  250.  
  251. . {
  252.     fprintf(stderr,"\tERREUR : Lexeme inconnu a la ligne %d. Il s'agit de %s et comporte %d lettre(s)\n",lineno,yytext,yyleng);
  253.     error_lexical=true;
  254.     return yytext[0];
  255. }
  256.  
  257. %%
  258.  
  259. /* fonction de concatenation - realloue la memoire a la variable texte dimensionne a la taille memoire du tableau de char ajout puis concatene */
  260.  
  261. void* concat(char* texte, char* ajout){
  262.     void* p=NULL;
  263.     /* realloue la memoire -> taille de texte + taille de ajout + 1 (caractere de fin \0) */
  264.     if((p=realloc(texte,sizeof(char)*(strlen(texte)+strlen(ajout)+1)))){
  265.         texte=p;
  266.         return strcat(texte,ajout);
  267.     }else{
  268.         /* appel de la macro FREE pour liberer correctement la memoire */
  269.         FREE(texte);
  270.         return NULL;
  271.     }
  272. }

On met à jour le fichier d'entête. L'affichage d'un double en C est différent que celui d'un long. Il faut donc prendre en compte cette différence. De même dans l'affectation.

simple.h
  1. #define DECIMAL             56
  2. #define AFFECTATIOND        57
  3. #define AFFICHAGED          58

Maintenant on passe à l'analyseur syntaxique. Il faudra être très vigilant au niveau de l'analyse sémantique. En effet un nombre décimal est une expression arithmétique et un nombre entier est aussi une expression arithmétique. Donc si on demande d'afficher une expression arithmétique, il faut que le langage sache si l'expression contient un nombre décimal et donc par conséquent fait l'affichage d'un double classique en C ou ne contient pas de décimaux et affiche donc un entier. Nous allons créer une fonction qui prend en argument un noeud d'arbre (l'expression arithmetique) et renvoie true ou false selon la nature de l'expression.

syntaxe_bison.y
  1. %{
  2.  
  3. #include "simple.h"
  4. bool error_syntaxical=false;
  5. bool error_semantical=false;
  6. /* Notre table de hachage */
  7. GHashTable* table_variable;
  8.  
  9. /* Fonction de suppression des variables declarees a l'interieur d'un arbre syntaxique */
  10. void supprime_variable(GNode*);
  11.  
  12. /* Fonction permettant de dire si un noeud d'arbre contient un decimal ou non */
  13. bool decimal(GNode*);
  14.  
  15. /* Notre structure Variable qui a comme membre le type et un pointeur generique vers la valeur */
  16. typedef struct Variable Variable;
  17.  
  18. struct Variable{
  19.         char* type;
  20.         GNode* value;
  21. };
  22.  
  23. %}
  24.  
  25. /* L'union dans Bison est utilisee pour typer nos tokens ainsi que nos non terminaux. Ici nous avons declare une union avec trois types : nombre de type int, texte de type pointeur de char (char*) et noeud d'arbre syntaxique (AST) de type (GNode*) */
  26.  
  27. %union {
  28.         long entier;
  29.         double decimal;
  30.         char* texte;
  31.         GNode*  noeud;
  32. }
  33.  
  34. /* Nous avons ici les operateurs, ils sont definis par leur ordre de priorite. Si je definis par exemple la multiplication en premier et l'addition apres, le + l'emportera alors sur le * dans le langage. Les parenthese sont prioritaires avec %right */
  35.  
  36. %left                   TOK_INCREMENTATION      TOK_DECREMENTATION      /* ++ -- */
  37. %left                   TOK_PLUS        TOK_MOINS       /* +- */
  38. %left                   TOK_MUL         TOK_DIV         TOK_MOD         /* /*% */
  39. %left                   TOK_PUISSANCE   /* ^ */
  40. %left                   TOK_ET          TOK_OU          TOK_NON         /* et ou non */
  41. %left                   TOK_EQU         TOK_DIFF        TOK_SUP         TOK_INF         TOK_SUPEQU      TOK_INFEQU      /* comparaisons */
  42. %right                  TOK_PARG        TOK_PARD        /* () */
  43.  
  44. /* Nous avons la liste de nos expressions (les non terminaux). Nous les typons tous en noeud de l'arbre syntaxique (GNode*) */
  45.  
  46. %type<noeud>            code
  47. %type<noeud>            bloc_code
  48. %type<noeud>            commentaire
  49. %type<noeud>            instruction
  50. %type<noeud>        condition
  51. %type<noeud>        condition_si
  52. %type<noeud>        condition_sinon
  53. %type<noeud>        boucle_for
  54. %type<noeud>        boucle_while
  55. %type<noeud>        boucle_do_while
  56. %type<noeud>            variable_entiere
  57. %type<noeud>            variable_decimale
  58. %type<noeud>            variable_booleenne
  59. %type<noeud>            variable_texte
  60. %type<noeud>            affectation
  61. %type<noeud>            affichage
  62. %type<noeud>            suppression
  63. %type<noeud>            expression_arithmetique
  64. %type<noeud>            expression_booleenne
  65. %type<noeud>            expression_texte
  66. %type<noeud>            addition
  67. %type<noeud>            soustraction
  68. %type<noeud>            multiplication
  69. %type<noeud>            division
  70. %type<noeud>            modulo
  71.  
  72. /* Nous avons la liste de nos tokens (les terminaux de notre grammaire) */
  73.  
  74. %token<entier>          TOK_ENTIER
  75. %token<decimal>         TOK_DECIMAL
  76. %token                  TOK_VRAI        /* true */
  77. %token                  TOK_FAUX        /* false */
  78. %token                  TOK_AFFECT      /* = */
  79. %token                  TOK_FINSTR      /* ; */
  80. %token                  TOK_IN          /* dans */
  81. %token                  TOK_CROG    TOK_CROD    /* [] */
  82. %token                  TOK_AFFICHER    /* afficher */
  83. %token<texte>           TOK_VARB        /* variable booleenne */
  84. %token<texte>           TOK_VARE        /* variable entiere */
  85. %token<texte>           TOK_VARD        /* variable decimale */
  86. %token<texte>                   TOK_VART
  87. %token                  TOK_SI          /* si */
  88. %token                  TOK_ALORS       /* alors */
  89. %token                  TOK_SINON       /* sinon */
  90. %token                                  TOK_COMMENT             /* commentaire */
  91. %token                                  TOK_AFFECT_PLUS TOK_AFFECT_MOINS        TOK_AFFECT_MUL  TOK_AFFECT_DIV  TOK_AFFECT_MOD  /* += -= *= /= %= */
  92. %token                                  TOK_AFFECT_ET   TOK_AFFECT_OU   /* &= |= */
  93. %token                                  TOK_POINT_INTERROGATION /* ? */
  94. %token                                  TOK_DOUBLE_POINT        /* : */
  95. %token                                  TOK_FAIRE               /* faire */
  96. %token                                  TOK_CROIX               /* x */
  97. %token<texte>                   TOK_TEXTE               /* texte libre */
  98. %token                                  TOK_SUPPR               /* supprimer */
  99.  
  100. %%
  101.  
  102. /* Nous definissons toutes les regles grammaticales de chaque non terminal de notre langage. Par defaut on commence a definir l'axiome, c'est a dire ici le non terminal code. Si nous le definissons pas en premier nous devons le specifier en option dans Bison avec %start */
  103.  
  104. entree:         code{
  105.                                 genere_code($1);
  106.                                 g_node_destroy($1);
  107.                         };
  108.  
  109. bloc_code:      code{
  110.                                 $$=g_node_new((gpointer)BLOC_CODE);
  111.                                 g_node_append($$,$1);
  112.                                 supprime_variable($1);
  113.                         }
  114.  
  115. code:           %empty{$$=g_node_new((gpointer)CODE_VIDE);}
  116.                 |
  117.                 code commentaire{
  118.                         $$=g_node_new((gpointer)SEQUENCE);
  119.                         g_node_append($$,$1);
  120.                         g_node_append($$,$2);
  121.                 }
  122.                 |
  123.                 code instruction{
  124.                         printf("Resultat : C'est une instruction valide !\n\n");
  125.                         $$=g_node_new((gpointer)SEQUENCE);
  126.                         g_node_append($$,$1);
  127.                         g_node_append($$,$2);
  128.                 }
  129.                 |
  130.                 code error{
  131.                         fprintf(stderr,"\tERREUR : Erreur de syntaxe a la ligne %d.\n",lineno);
  132.                         error_syntaxical=true;
  133.                 };
  134.  
  135. commentaire:    TOK_COMMENT{
  136.                                         $$=g_node_new((gpointer)CODE_VIDE);
  137.                                 };
  138.  
  139. instruction:    affectation{
  140.                         printf("\tInstruction type Affectation\n");
  141.                         $$=$1;
  142.                 }
  143.                 |
  144.                 affichage{
  145.                         printf("\tInstruction type Affichage\n");
  146.                         $$=$1;
  147.                 }
  148.                 |
  149.                 condition{
  150.                     printf("Condition si/sinon\n");
  151.                     $$=$1;
  152.                 }
  153.                 |
  154.                 boucle_for{
  155.                         printf("Boucle repetee\n");
  156.                         $$=$1;
  157.                 }
  158.                 |
  159.                 boucle_while{
  160.                         printf("Boucle tant que\n");
  161.                         $$=$1;
  162.                 }
  163.                 |
  164.                 boucle_do_while{
  165.                         printf("Boucle faire tant que\n");
  166.                         $$=$1;
  167.                 }
  168.                 |
  169.                 suppression{
  170.                         printf("\tInstruction type Suppression\n");
  171.                         $$=$1;
  172.                 };
  173.  
  174. variable_entiere:       TOK_VARE{
  175.                                 printf("\t\t\tVariable entiere %s\n",$1);
  176.                                 $$=g_node_new((gpointer)VARIABLE);
  177.                                 g_node_append_data($$,strdup($1));
  178.                         };
  179.  
  180. variable_decimale:      TOK_VARD{
  181.                                 printf("\t\t\tVariable decimale %s\n",$1);
  182.                                 $$=g_node_new((gpointer)VARIABLE);
  183.                                 g_node_append_data($$,strdup($1));
  184.                         };
  185.  
  186. variable_booleenne:     TOK_VARB{
  187.                                 printf("\t\t\tVariable booleenne %s\n",$1);
  188.                                 $$=g_node_new((gpointer)VARIABLE);
  189.                                 g_node_append_data($$,strdup($1));
  190.                         };
  191.  
  192. variable_texte: TOK_VART{
  193.                                 printf("\t\t\tVariable texte %s\n",$1);
  194.                                 $$=g_node_new((gpointer)VARIABLE);
  195.                                 g_node_append_data($$,strdup($1));
  196.                         };
  197.  
  198. condition:      condition_si TOK_FINSTR{
  199.                     printf("\tCondition si\n");
  200.                     $$=g_node_new((gpointer)CONDITION_SI);
  201.                     g_node_append($$,$1);
  202.                 }
  203.                 |
  204.                 condition_si condition_sinon TOK_FINSTR{
  205.                     printf("\tCondition si/sinon\n");
  206.                     $$=g_node_new((gpointer)CONDITION_SI_SINON);
  207.                     g_node_append($$,$1);
  208.                     g_node_append($$,$2);
  209.                 }
  210.                 |
  211.                 TOK_PARG expression_booleenne TOK_PARD TOK_POINT_INTERROGATION bloc_code TOK_DOUBLE_POINT bloc_code TOK_FINSTR{
  212.                         printf("\tCondition si/sinon\n");
  213.                     $$=g_node_new((gpointer)CONDITION_SI_SINON);
  214.                     g_node_append($$,g_node_new((gpointer)SI));
  215.                     g_node_append(g_node_nth_child($$,0),$2);
  216.                     g_node_append(g_node_nth_child($$,0),$5);
  217.                     g_node_append($$,g_node_new((gpointer)SINON));
  218.                     g_node_append(g_node_nth_child($$,1),$7);
  219.  
  220.                 };
  221.  
  222. condition_si:   TOK_SI expression_booleenne TOK_ALORS bloc_code{
  223.                     $$=g_node_new((gpointer)SI);
  224.                     g_node_append($$,$2);
  225.                     g_node_append($$,$4);
  226.                 };
  227.  
  228. condition_sinon:   TOK_SINON bloc_code{
  229.                         $$=g_node_new((gpointer)SINON);
  230.                         g_node_append($$,$2);
  231.                     };
  232.  
  233. boucle_for:             TOK_PARG expression_arithmetique TOK_PARD TOK_CROIX bloc_code TOK_FINSTR{
  234.                                         $$=g_node_new((gpointer)BOUCLE_FOR);
  235.                                         g_node_append($$,g_node_new((gpointer)ENTIER));
  236.                                         g_node_append_data(g_node_nth_child($$,0),strdup("0"));
  237.                                         g_node_append($$,g_node_new((gpointer)ENTIER));
  238.                                         g_node_append_data(g_node_nth_child($$,1),strdup("1"));
  239.                     g_node_append($$,$2);
  240.                     g_node_append($$,$5);
  241.                                 }
  242.                                 |
  243.                                 TOK_PARG expression_arithmetique TOK_DOUBLE_POINT expression_arithmetique TOK_PARD bloc_code TOK_FINSTR{
  244.                                         $$=g_node_new((gpointer)BOUCLE_FOR);
  245.                                         g_node_append($$,$2);
  246.                                         g_node_append($$,g_node_new((gpointer)ENTIER));
  247.                                         g_node_append_data(g_node_nth_child($$,1),strdup("1"));
  248.                     g_node_append($$,$4);
  249.                     g_node_append($$,$6);
  250.                                 }
  251.                                 |
  252.                                 TOK_PARG expression_arithmetique TOK_DOUBLE_POINT expression_arithmetique TOK_DOUBLE_POINT expression_arithmetique TOK_PARD bloc_code TOK_FINSTR{
  253.                                         $$=g_node_new((gpointer)BOUCLE_FOR);
  254.                                         g_node_append($$,$2);
  255.                     g_node_append($$,$4);
  256.                     g_node_append($$,$6);
  257.                     g_node_append($$,$8);
  258.                                 };
  259.  
  260. boucle_while:   TOK_PARG expression_booleenne TOK_PARD TOK_POINT_INTERROGATION bloc_code TOK_FINSTR{
  261.                                         $$=g_node_new((gpointer)BOUCLE_WHILE);
  262.                                         g_node_append($$,$2);
  263.                     g_node_append($$,$5);
  264.                                 };
  265.  
  266. boucle_do_while:        TOK_FAIRE bloc_code TOK_POINT_INTERROGATION TOK_PARG expression_booleenne TOK_PARD TOK_FINSTR{
  267.                                                 $$=g_node_new((gpointer)BOUCLE_DO_WHILE);
  268.                                                 g_node_append($$,$2);
  269.                             g_node_append($$,$5);
  270.                                         };
  271.  
  272. affectation:    variable_entiere TOK_AFFECT expression_arithmetique TOK_FINSTR{
  273.                         /* $1 est la valeur du premier non terminal. Ici c'est la valeur du non terminal variable. $3 est la valeur du 2nd non terminal. */
  274.                         printf("\t\tAffectation sur la variable\n");
  275.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  276.                         if(var==NULL){
  277.                                 /* On cree une Variable et on lui affecte le type que nous connaissons et la valeur */
  278.                                 var=malloc(sizeof(Variable));
  279.                                 if(var!=NULL){
  280.                                         var->type=strdup("entier");
  281.                                         var->value=$3;
  282.                                         /* On l'insere dans la table de hachage (cle: <nom_variable> / valeur: <(type,valeur)>) */
  283.                                         if(g_hash_table_insert(table_variable,g_node_nth_child($1,0)->data,var)){
  284.                                         $$=g_node_new((gpointer)AFFECTATIONE);
  285.                                         g_node_append($$,$1);
  286.                                         g_node_append($$,$3);
  287.                                         }else{
  288.                                             fprintf(stderr,"ERREUR - PROBLEME CREATION VARIABLE !\n");
  289.                                             exit(-1);
  290.                                         }
  291.                                 }else{
  292.                                         fprintf(stderr,"ERREUR - PROBLEME ALLOCATION MEMOIRE VARIABLE !\n");
  293.                                         exit(-1);
  294.                                 }
  295.                         }else{
  296.                                 $$=g_node_new((gpointer)AFFECTATION);
  297.                                 g_node_append($$,$1);
  298.                                 g_node_append($$,$3);
  299.                         }
  300.                 }
  301.                 |
  302.                 variable_entiere TOK_AFFECT_PLUS expression_arithmetique TOK_FINSTR{
  303.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  304.                         if(var==NULL){
  305.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  306.                                 error_semantical=true;
  307.                         }else{
  308.                                 $$=g_node_new((gpointer)AFFECTATION_PLUS);
  309.                                 g_node_append($$,$1);
  310.                                 g_node_append($$,$3);
  311.                         }
  312.                 }
  313.                 |
  314.                 variable_entiere TOK_AFFECT_MOINS expression_arithmetique TOK_FINSTR{
  315.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  316.                         if(var==NULL){
  317.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  318.                                 error_semantical=true;
  319.                         }else{
  320.                                 $$=g_node_new((gpointer)AFFECTATION_MOINS);
  321.                                 g_node_append($$,$1);
  322.                                 g_node_append($$,$3);
  323.                         }
  324.                 }
  325.                 |
  326.                 variable_entiere TOK_AFFECT_MUL expression_arithmetique TOK_FINSTR{
  327.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  328.                         if(var==NULL){
  329.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  330.                                 error_semantical=true;
  331.                         }else{
  332.                                 $$=g_node_new((gpointer)AFFECTATION_MUL);
  333.                                 g_node_append($$,$1);
  334.                                 g_node_append($$,$3);
  335.                         }
  336.                 }
  337.                 |
  338.                 variable_entiere TOK_AFFECT_DIV expression_arithmetique TOK_FINSTR{
  339.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  340.                         if(var==NULL){
  341.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  342.                                 error_semantical=true;
  343.                         }else{
  344.                                 $$=g_node_new((gpointer)AFFECTATION_DIV);
  345.                                 g_node_append($$,$1);
  346.                                 g_node_append($$,$3);
  347.                         }
  348.                 }
  349.                 |
  350.                 variable_entiere TOK_AFFECT_MOD expression_arithmetique TOK_FINSTR{
  351.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  352.                         if(var==NULL){
  353.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  354.                                 error_semantical=true;
  355.                         }else{
  356.                                 $$=g_node_new((gpointer)AFFECTATION_MOD);
  357.                                 g_node_append($$,$1);
  358.                                 g_node_append($$,$3);
  359.                         }
  360.                 }
  361.                 |
  362.                 variable_entiere TOK_INCREMENTATION TOK_FINSTR{
  363.                         printf("\t\t\tIncrementation de +1 sur la variable\n");
  364.                     $$=g_node_new((gpointer)AFFECTATION_INCR);
  365.                     g_node_append($$,$1);
  366.                 }
  367.                 |
  368.                 variable_entiere TOK_DECREMENTATION TOK_FINSTR{
  369.                         printf("\t\t\tDecrementation de -1 sur la variable\n");
  370.                     $$=g_node_new((gpointer)AFFECTATION_DECR);
  371.                     g_node_append($$,$1);
  372.                 }
  373.                 |
  374.                 variable_decimale TOK_AFFECT expression_arithmetique TOK_FINSTR{
  375.                         /* $1 est la valeur du premier non terminal. Ici c'est la valeur du non terminal variable. $3 est la valeur du 2nd non terminal. */
  376.                         printf("\t\tAffectation sur la variable\n");
  377.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  378.                         if(var==NULL){
  379.                                 /* On cree une Variable et on lui affecte le type que nous connaissons et la valeur */
  380.                                 var=malloc(sizeof(Variable));
  381.                                 if(var!=NULL){
  382.                                         var->type=strdup("decimal");
  383.                                         var->value=$3;
  384.                                         /* On l'insere dans la table de hachage (cle: <nom_variable> / valeur: <(type,valeur)>) */
  385.                                         if(g_hash_table_insert(table_variable,g_node_nth_child($1,0)->data,var)){
  386.                                         $$=g_node_new((gpointer)AFFECTATIOND);
  387.                                         g_node_append($$,$1);
  388.                                         g_node_append($$,$3);
  389.                                         }else{
  390.                                             fprintf(stderr,"ERREUR - PROBLEME CREATION VARIABLE !\n");
  391.                                             exit(-1);
  392.                                         }
  393.                                 }else{
  394.                                         fprintf(stderr,"ERREUR - PROBLEME ALLOCATION MEMOIRE VARIABLE !\n");
  395.                                         exit(-1);
  396.                                 }
  397.                         }else{
  398.                                 $$=g_node_new((gpointer)AFFECTATION);
  399.                                 g_node_append($$,$1);
  400.                                 g_node_append($$,$3);
  401.                         }
  402.                 }
  403.                 |
  404.                 variable_decimale TOK_AFFECT_PLUS expression_arithmetique TOK_FINSTR{
  405.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  406.                         if(var==NULL){
  407.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  408.                                 error_semantical=true;
  409.                         }else{
  410.                                 $$=g_node_new((gpointer)AFFECTATION_PLUS);
  411.                                 g_node_append($$,$1);
  412.                                 g_node_append($$,$3);
  413.                         }
  414.                 }
  415.                 |
  416.                 variable_decimale TOK_AFFECT_MOINS expression_arithmetique TOK_FINSTR{
  417.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  418.                         if(var==NULL){
  419.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  420.                                 error_semantical=true;
  421.                         }else{
  422.                                 $$=g_node_new((gpointer)AFFECTATION_MOINS);
  423.                                 g_node_append($$,$1);
  424.                                 g_node_append($$,$3);
  425.                         }
  426.                 }
  427.                 |
  428.                 variable_decimale TOK_AFFECT_MUL expression_arithmetique TOK_FINSTR{
  429.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  430.                         if(var==NULL){
  431.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  432.                                 error_semantical=true;
  433.                         }else{
  434.                                 $$=g_node_new((gpointer)AFFECTATION_MUL);
  435.                                 g_node_append($$,$1);
  436.                                 g_node_append($$,$3);
  437.                         }
  438.                 }
  439.                 |
  440.                 variable_decimale TOK_AFFECT_DIV expression_arithmetique TOK_FINSTR{
  441.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  442.                         if(var==NULL){
  443.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  444.                                 error_semantical=true;
  445.                         }else{
  446.                                 $$=g_node_new((gpointer)AFFECTATION_DIV);
  447.                                 g_node_append($$,$1);
  448.                                 g_node_append($$,$3);
  449.                         }
  450.                 }
  451.                 |
  452.                 variable_decimale TOK_AFFECT_MOD expression_arithmetique TOK_FINSTR{
  453.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  454.                         if(var==NULL){
  455.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  456.                                 error_semantical=true;
  457.                         }else{
  458.                                 $$=g_node_new((gpointer)AFFECTATION_MOD);
  459.                                 g_node_append($$,$1);
  460.                                 g_node_append($$,$3);
  461.                         }
  462.                 }
  463.                 |
  464.                 variable_decimale TOK_INCREMENTATION TOK_FINSTR{
  465.                         printf("\t\t\tIncrementation de +1 sur la variable\n");
  466.                     $$=g_node_new((gpointer)AFFECTATION_INCR);
  467.                     g_node_append($$,$1);
  468.                 }
  469.                 |
  470.                 variable_decimale TOK_DECREMENTATION TOK_FINSTR{
  471.                         printf("\t\t\tDecrementation de -1 sur la variable\n");
  472.                     $$=g_node_new((gpointer)AFFECTATION_DECR);
  473.                     g_node_append($$,$1);
  474.                 }
  475.                 |
  476.                 variable_booleenne TOK_AFFECT expression_booleenne TOK_FINSTR{
  477.                         /* $1 est la valeur du premier non terminal. Ici c'est la valeur du non terminal variable. $3 est la valeur du 2nd non terminal. */
  478.                         printf("\t\tAffectation sur la variable\n");
  479.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  480.                         if(var==NULL){
  481.                                 /* On cree une Variable et on lui affecte le type que nous connaissons et la valeur */
  482.                                 var=malloc(sizeof(Variable));
  483.                                 if(var!=NULL){
  484.                                         var->type=strdup("booleen");
  485.                                         var->value=$3;
  486.                                         /* On l'insere dans la table de hachage (cle: <nom_variable> / valeur: <(type,valeur)>) */
  487.                                         if(g_hash_table_insert(table_variable,g_node_nth_child($1,0)->data,var)){
  488.                                         $$=g_node_new((gpointer)AFFECTATIONB);
  489.                                         g_node_append($$,$1);
  490.                                         g_node_append($$,$3);
  491.                                         }else{
  492.                                             fprintf(stderr,"ERREUR - PROBLEME CREATION VARIABLE !\n");
  493.                                             exit(-1);
  494.                                         }
  495.                                 }else{
  496.                                         fprintf(stderr,"ERREUR - PROBLEME ALLOCATION MEMOIRE VARIABLE !\n");
  497.                                         exit(-1);
  498.                                 }
  499.                         }else{
  500.                                 $$=g_node_new((gpointer)AFFECTATION);
  501.                                 g_node_append($$,$1);
  502.                                 g_node_append($$,$3);
  503.                         }
  504.                 }
  505.                 |
  506.                 variable_booleenne TOK_AFFECT_ET expression_booleenne TOK_FINSTR{
  507.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  508.                         if(var==NULL){
  509.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  510.                                 error_semantical=true;
  511.                         }else{
  512.                                 $$=g_node_new((gpointer)AFFECTATION_ET);
  513.                                 g_node_append($$,$1);
  514.                                 g_node_append($$,$3);
  515.                         }
  516.                 }
  517.                 |
  518.                 variable_booleenne TOK_AFFECT_OU expression_booleenne TOK_FINSTR{
  519.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  520.                         if(var==NULL){
  521.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  522.                                 error_semantical=true;
  523.                         }else{
  524.                                 $$=g_node_new((gpointer)AFFECTATION_OU);
  525.                                 g_node_append($$,$1);
  526.                                 g_node_append($$,$3);
  527.                         }
  528.                 }
  529.                 |
  530.                 variable_texte TOK_AFFECT expression_texte TOK_FINSTR{
  531.                         /* $1 est la valeur du premier non terminal. Ici c'est la valeur du non terminal variable. $3 est la valeur du 2nd non terminal. */
  532.                         printf("\t\tAffectation sur la variable\n");
  533.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  534.                         if(var==NULL){
  535.                                 /* On cree une Variable et on lui affecte le type que nous connaissons et la valeur */
  536.                                 var=malloc(sizeof(Variable));
  537.                                 if(var!=NULL){
  538.                                         var->type=strdup("texte");
  539.                                         var->value=$3;
  540.                                         /* On l'insere dans la table de hachage (cle: <nom_variable> / valeur: <(type,valeur)>) */
  541.                                         if(g_hash_table_insert(table_variable,g_node_nth_child($1,0)->data,var)){
  542.                                         $$=g_node_new((gpointer)AFFECTATIONT);
  543.                                         g_node_append($$,$1);
  544.                                         g_node_append($$,$3);
  545.                                         }else{
  546.                                             fprintf(stderr,"ERREUR - PROBLEME CREATION VARIABLE !\n");
  547.                                             exit(-1);
  548.                                         }
  549.                                 }else{
  550.                                         fprintf(stderr,"ERREUR - PROBLEME ALLOCATION MEMOIRE VARIABLE !\n");
  551.                                         exit(-1);
  552.                                 }
  553.                         }else{
  554.                                 $$=g_node_new((gpointer)AFFECTATION);
  555.                                 g_node_append($$,$1);
  556.                                 g_node_append($$,$3);
  557.                         }
  558.                 }
  559.                 |
  560.                 variable_texte TOK_AFFECT_PLUS expression_texte TOK_FINSTR{
  561.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  562.                         if(var==NULL){
  563.                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  564.                                 error_semantical=true;
  565.                         }else{
  566.                                 $$=g_node_new((gpointer)AFFECTATIONT_CONCAT);
  567.                                 g_node_append($$,$1);
  568.                                 g_node_append($$,$3);
  569.                         }
  570.                 };
  571.  
  572. affichage:      TOK_AFFICHER expression_arithmetique TOK_FINSTR{
  573.                         printf("\t\tAffichage de la valeur de l'expression arithmetique\n");
  574.                         if(decimal($2)){
  575.                                 $$=g_node_new((gpointer)AFFICHAGED);
  576.                                 g_node_append($$,$2);
  577.                         }else{
  578.                                 $$=g_node_new((gpointer)AFFICHAGEE);
  579.                                 g_node_append($$,$2);
  580.                         }
  581.                 }
  582.                 |
  583.                 TOK_AFFICHER expression_booleenne TOK_FINSTR{
  584.                         printf("\t\tAffichage de la valeur de l'expression booleenne\n");
  585.                         $$=g_node_new((gpointer)AFFICHAGEB);
  586.                         g_node_append($$,$2);
  587.                 }
  588.                 |
  589.                 TOK_AFFICHER expression_texte TOK_FINSTR{
  590.                         printf("\t\tAffichage de la valeur de l'expression textuelle\n");
  591.                         $$=g_node_new((gpointer)AFFICHAGET);
  592.                         g_node_append($$,$2);
  593.                 };
  594.  
  595. suppression:    TOK_SUPPR variable_texte TOK_FINSTR{
  596.                                         /* On recupere un pointeur vers la structure Variable */
  597.                                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($2,0)->data);
  598.                                         /* Si on a trouve un pointeur valable */
  599.                                         if(var!=NULL){
  600.                                                 /* On verifie que le type est bien un entier - Inutile car impose a l'analyse syntaxique */
  601.                                                 if(strcmp(var->type,"texte")==0){
  602.                                                         printf("\t\t\tSuppression de la variable texte\n");
  603.                                                         $$=g_node_new((gpointer)SUPPRESSIONT);
  604.                                                         g_node_append($$,$2);
  605.                                                         /* suppression de la variable dans la table de hachage */
  606.                                                         printf("suppresion variable %s\n",(char*)g_node_nth_child($2,0)->data);
  607.                                                     if(g_hash_table_remove(table_variable,(char*)g_node_nth_child($2,0)->data)){
  608.                                                         printf("Variable supprimee !\n");
  609.                                                     }else{
  610.                                                         fprintf(stderr,"ERREUR - PROBLEME DE SUPPRESSION VARIABLE !\n");
  611.                                                         exit(-1);
  612.                                                     }
  613.                                                 }else{
  614.                                                         fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Type incompatible !\n",lineno);
  615.                                                         error_semantical=true;
  616.                                                 }
  617.                                         /* Sinon on conclue que la variable n'a jamais ete declaree car absente de la table */
  618.                                         }else{
  619.                                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($2,0)->data);
  620.                                                 error_semantical=true;
  621.                                         }
  622.                                 }
  623.  
  624. expression_arithmetique:        TOK_ENTIER{
  625.                                         printf("\t\t\tNombre entier : %ld\n",$1);
  626.                                         /* Comme le token TOK_NOMBRE est de type entier et que on a type expression_arithmetique comme du texte, il nous faut convertir la valeur en texte. */
  627.                                         int length=snprintf(NULL,0,"%ld",$1);
  628.                                         char* str=malloc(length+1);
  629.                                         snprintf(str,length+1,"%ld",$1);
  630.                                         $$=g_node_new((gpointer)ENTIER);
  631.                                         g_node_append_data($$,strdup(str));
  632.                                         free(str);
  633.                                 }
  634.                                 |
  635.                                 TOK_DECIMAL{
  636.                                         printf("\t\t\tNombre decimal : %f\n",$1);
  637.                                         /* Comme le token TOK_NOMBRE est de type entier et que on a type expression_arithmetique comme du texte, il nous faut convertir la valeur en texte. */
  638.                                         int length=snprintf(NULL,0,"%f",$1);
  639.                                         char* str=malloc(length+1);
  640.                                         snprintf(str,length+1,"%f",$1);
  641.                                         $$=g_node_new((gpointer)DECIMAL);
  642.                                         g_node_append_data($$,strdup(str));
  643.                                         free(str);
  644.                                 }
  645.                                 |
  646.                                 variable_entiere{
  647.                                         /* On recupere un pointeur vers la structure Variable */
  648.                                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  649.                                         /* Si on a trouve un pointeur valable */
  650.                                         if(var!=NULL){
  651.                                                 /* On verifie que le type est bien un entier ou un decimal - Inutile car impose a l'analyse syntaxique */
  652.                                                 if(strcmp(var->type,"entier")==0){
  653.                                                         $$=$1;
  654.                                                 }else{
  655.                                                         fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Type incompatible (entier attendu - valeur : %s) !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  656.                                                         error_semantical=true;
  657.                                                 }
  658.                                         /* Sinon on conclue que la variable n'a jamais ete declaree car absente de la table */
  659.                                         }else{
  660.                                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  661.                                                 error_semantical=true;
  662.                                         }
  663.                                 }
  664.                                 |
  665.                                 variable_decimale{
  666.                                         /* On recupere un pointeur vers la structure Variable */
  667.                                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  668.                                         /* Si on a trouve un pointeur valable */
  669.                                         if(var!=NULL){
  670.                                                 /* On verifie que le type est bien un entier ou un decimal - Inutile car impose a l'analyse syntaxique */
  671.                                                 if(strcmp(var->type,"decimal")==0){
  672.                                                         $$=$1;
  673.                                                 }else{
  674.                                                         fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Type incompatible (decimal attendu - valeur : %s) !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  675.                                                         error_semantical=true;
  676.                                                 }
  677.                                         /* Sinon on conclue que la variable n'a jamais ete declaree car absente de la table */
  678.                                         }else{
  679.                                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  680.                                                 error_semantical=true;
  681.                                         }
  682.                                 }
  683.                                 |
  684.                                 addition{
  685.                                         $$=$1;
  686.                                 }
  687.                                 |
  688.                                 soustraction{
  689.                                         $$=$1;
  690.                                 }
  691.                                 |
  692.                                 multiplication{
  693.                                         $$=$1;
  694.                                 }
  695.                                 |
  696.                                 division{
  697.                                         $$=$1;
  698.                                 }
  699.                                 |
  700.                                 modulo{
  701.                                         $$=$1;
  702.                                 }
  703.                                 |
  704.                                 TOK_PLUS expression_arithmetique{
  705.                                     $$=$2;
  706.                                 }
  707.                                 |
  708.                                 expression_arithmetique TOK_INCREMENTATION{
  709.                                         printf("\t\t\tIncrementation de +1\n");
  710.                                     $$=g_node_new((gpointer)INCREMENTATION);
  711.                                     g_node_append($$,$1);
  712.                                 }
  713.                                 |
  714.                                 expression_arithmetique TOK_DECREMENTATION{
  715.                                         printf("\t\t\tDecrementation de -1\n");
  716.                                     $$=g_node_new((gpointer)DECREMENTATION);
  717.                                     g_node_append($$,$1);
  718.                                 }
  719.                                 |
  720.                                 TOK_MOINS expression_arithmetique{
  721.                                     printf("\t\t\tOperation unaire negation\n");
  722.                                     $$=g_node_new((gpointer)NEGATIF);
  723.                                         g_node_append($$,$2);
  724.                                 }
  725.                                 |
  726.                                 TOK_PARG expression_arithmetique TOK_PARD{
  727.                                         printf("\t\t\tC'est une expression arithmetique entre parentheses\n");
  728.                                         $$=g_node_new((gpointer)EXPR_PAR);
  729.                                         g_node_append($$,$2);
  730.                                 };
  731.  
  732. expression_booleenne:           TOK_VRAI{
  733.                                         printf("\t\t\tBooleen Vrai\n");
  734.                                         $$=g_node_new((gpointer)VRAI);
  735.                                 }
  736.                                 |
  737.                                 TOK_FAUX{
  738.                                         printf("\t\t\tBooleen Faux\n");
  739.                                         $$=g_node_new((gpointer)FAUX);
  740.                                 }
  741.                                 |
  742.                                 variable_booleenne{
  743.                                         /* On recupere un pointeur vers la structure Variable */
  744.                                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  745.                                         /* Si on a trouve un pointeur valable */
  746.                                         if(var!=NULL){
  747.                                                 /* On verifie que le type est bien un entier - Inutile car impose a l'analyse syntaxique */
  748.                                                 if(strcmp(var->type,"booleen")==0){
  749.                                                         $$=$1;
  750.                                                 }else{
  751.                                                         fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Type incompatible (booleen attendu - valeur : %s) !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  752.                                                         error_semantical=true;
  753.                                                 }
  754.                                         /* Sinon on conclue que la variable n'a jamais ete declaree car absente de la table */
  755.                                         }else{
  756.                                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  757.                                                 error_semantical=true;
  758.                                         }
  759.                                 }
  760.                                 |
  761.                                 TOK_NON expression_booleenne{
  762.                                         printf("\t\t\tOperation booleenne Non\n");
  763.                                         $$=g_node_new((gpointer)NON);
  764.                                         g_node_append($$,$2);
  765.                                 }
  766.                                 |
  767.                                 expression_booleenne TOK_ET expression_booleenne{
  768.                                         printf("\t\t\tOperation booleenne Et\n");
  769.                                         $$=g_node_new((gpointer)ET);
  770.                                         g_node_append($$,$1);
  771.                                         g_node_append($$,$3);
  772.                                 }
  773.                                 |
  774.                                 expression_booleenne TOK_OU expression_booleenne{
  775.                                         printf("\t\t\tOperation booleenne Ou\n");
  776.                                         $$=g_node_new((gpointer)OU);
  777.                                         g_node_append($$,$1);
  778.                                         g_node_append($$,$3);
  779.                                 }
  780.                                 |
  781.                                 TOK_PARG expression_booleenne TOK_PARD{
  782.                                         printf("\t\t\tC'est une expression booleenne entre parentheses\n");
  783.                                         $$=g_node_new((gpointer)EXPR_PAR);
  784.                                         g_node_append($$,$2);
  785.                                 }
  786.                                 |
  787.                                 expression_booleenne TOK_EQU expression_booleenne{
  788.                                         printf("\t\t\tOperateur d'egalite ==\n");
  789.                                         $$=g_node_new((gpointer)EGALITE);
  790.                                         g_node_append($$,$1);
  791.                                         g_node_append($$,$3);
  792.                                 }
  793.                                 |
  794.                                 expression_booleenne TOK_DIFF expression_booleenne{
  795.                                         printf("\t\t\tOperateur d'inegalite !=\n");
  796.                                         $$=g_node_new((gpointer)DIFFERENT);
  797.                                         g_node_append($$,$1);
  798.                                         g_node_append($$,$3);
  799.                                 }
  800.                                 |
  801.                                 expression_arithmetique TOK_EQU expression_arithmetique{
  802.                                         printf("\t\t\tOperateur d'egalite ==\n");
  803.                                         $$=g_node_new((gpointer)EGALITE);
  804.                                         g_node_append($$,$1);
  805.                                         g_node_append($$,$3);
  806.                                 }
  807.                                 |
  808.                                 expression_arithmetique TOK_DIFF expression_arithmetique{
  809.                                         printf("\t\t\tOperateur d'inegalite !=\n");
  810.                                         $$=g_node_new((gpointer)DIFFERENT);
  811.                                         g_node_append($$,$1);
  812.                                         g_node_append($$,$3);
  813.                                 }
  814.                                 |
  815.                                 expression_arithmetique TOK_SUP expression_arithmetique{
  816.                                         printf("\t\t\tOperateur de superiorite >\n");
  817.                                         $$=g_node_new((gpointer)SUPERIEUR);
  818.                                         g_node_append($$,$1);
  819.                                         g_node_append($$,$3);
  820.                                 }
  821.                                 |
  822.                                 expression_arithmetique TOK_INF expression_arithmetique{
  823.                                         printf("\t\t\tOperateur d'inferiorite <\n");
  824.                                         $$=g_node_new((gpointer)INFERIEUR);
  825.                                         g_node_append($$,$1);
  826.                                         g_node_append($$,$3);
  827.                                 }
  828.                                 |
  829.                                 expression_arithmetique TOK_SUPEQU expression_arithmetique{
  830.                                         printf("\t\t\tOperateur >=\n");
  831.                                         $$=g_node_new((gpointer)SUPEGAL);
  832.                                         g_node_append($$,$1);
  833.                                         g_node_append($$,$3);
  834.                                 }
  835.                                 |
  836.                                 expression_arithmetique TOK_INFEQU expression_arithmetique{
  837.                                         printf("\t\t\tOperateur <=\n");
  838.                                         $$=g_node_new((gpointer)INFEGAL);
  839.                                         g_node_append($$,$1);
  840.                                         g_node_append($$,$3);
  841.                                 }
  842.                                 |
  843.                 expression_arithmetique TOK_IN TOK_CROG expression_arithmetique TOK_FINSTR expression_arithmetique TOK_CROD{
  844.                                         printf("\t\t\tOperateur dans\n");
  845.                                         $$=g_node_new((gpointer)DANSII);
  846.                                         g_node_append($$,$1);
  847.                                         g_node_append($$,$4);
  848.                                         g_node_append($$,$6);
  849.                                 }
  850.                                 |
  851.                 expression_arithmetique TOK_IN TOK_CROD expression_arithmetique TOK_FINSTR expression_arithmetique TOK_CROD{
  852.                                         printf("\t\t\tOperateur dans\n");
  853.                                         $$=g_node_new((gpointer)DANSEI);
  854.                                         g_node_append($$,$1);
  855.                                         g_node_append($$,$4);
  856.                                         g_node_append($$,$6);
  857.                                 }
  858.                                 |
  859.                 expression_arithmetique TOK_IN TOK_CROG expression_arithmetique TOK_FINSTR expression_arithmetique TOK_CROG{
  860.                                         printf("\t\t\tOperateur dans\n");
  861.                                         $$=g_node_new((gpointer)DANSIE);
  862.                                         g_node_append($$,$1);
  863.                                         g_node_append($$,$4);
  864.                                         g_node_append($$,$6);
  865.                                 }
  866.                                 |
  867.                 expression_arithmetique TOK_IN TOK_CROD expression_arithmetique TOK_FINSTR expression_arithmetique TOK_CROG{
  868.                                         printf("\t\t\tOperateur dans\n");
  869.                                         $$=g_node_new((gpointer)DANSEE);
  870.                                         g_node_append($$,$1);
  871.                                         g_node_append($$,$4);
  872.                                         g_node_append($$,$6);
  873.                                 };
  874.  
  875. expression_texte:       TOK_TEXTE{
  876.                                                 printf("\t\t\tTexte %s\n",$1);
  877.                                                 $$=g_node_new((gpointer)TEXTE);
  878.                                                 g_node_append_data($$,strdup($1));
  879.                                         }
  880.                                         |
  881.                                         variable_texte{
  882.                                                 /* On recupere un pointeur vers la structure Variable */
  883.                                                 Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($1,0)->data);
  884.                                                 /* Si on a trouve un pointeur valable */
  885.                                                 if(var!=NULL){
  886.                                                         /* On verifie que le type est bien un entier - Inutile car impose a l'analyse syntaxique */
  887.                                                         if(strcmp(var->type,"texte")==0){
  888.                                                                 $$=$1;
  889.                                                         }else{
  890.                                                                 fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Type incompatible (texte attendu - valeur : %s) !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  891.                                                                 error_semantical=true;
  892.                                                         }
  893.                                                 /* Sinon on conclue que la variable n'a jamais ete declaree car absente de la table */
  894.                                                 }else{
  895.                                                         fprintf(stderr,"\tERREUR : Erreur de semantique a la ligne %d. Variable %s jamais declaree !\n",lineno,(char*)g_node_nth_child($1,0)->data);
  896.                                                         error_semantical=true;
  897.                                                 }
  898.                                         };
  899.  
  900. addition:       expression_arithmetique TOK_PLUS expression_arithmetique{
  901.                         printf("\t\t\tAddition\n");
  902.                         $$=g_node_new((gpointer)ADDITION);
  903.                         g_node_append($$,$1);
  904.                         g_node_append($$,$3);
  905.                 };
  906.  
  907. soustraction:   expression_arithmetique TOK_MOINS expression_arithmetique{
  908.                                 printf("\t\t\tSoustraction\n");
  909.                                 $$=g_node_new((gpointer)SOUSTRACTION);
  910.                                 g_node_append($$,$1);
  911.                                 g_node_append($$,$3);
  912.                         };
  913.  
  914. multiplication: expression_arithmetique TOK_MUL expression_arithmetique{
  915.                         printf("\t\t\tMultiplication\n");
  916.                         $$=g_node_new((gpointer)MULTIPLICATION);
  917.                         g_node_append($$,$1);
  918.                         g_node_append($$,$3);
  919.                 };
  920.  
  921. division:       expression_arithmetique TOK_DIV expression_arithmetique{
  922.                                 printf("\t\t\tDivision\n");
  923.                                 $$=g_node_new((gpointer)DIVISION);
  924.                                 g_node_append($$,$1);
  925.                                 g_node_append($$,$3);
  926.                         };
  927.  
  928. modulo:         expression_arithmetique TOK_MOD expression_arithmetique{
  929.                                 printf("\t\t\tModulo\n");
  930.                                 $$=g_node_new((gpointer)MODULO);
  931.                                 g_node_append($$,$1);
  932.                                 g_node_append($$,$3);
  933.                         };
  934.  
  935. %%
  936.  
  937. /* Dans la fonction main on appelle bien la routine yyparse() qui sera genere par Bison. Cette routine appellera yylex() de notre analyseur lexical. */
  938.  
  939. int main(int argc, char** argv){
  940.         /* recuperation du nom de fichier d'entree (langage Simple) donne en parametre */
  941.         char* fichier_entree=strdup(argv[1]);
  942.         /* ouverture du fichier en lecture dans le flux d'entree stdin */
  943.         stdin=fopen(fichier_entree,"r");
  944.         /* creation fichier de sortie (langage C) */
  945.         char* fichier_sortie=strdup(argv[1]);
  946.         /* remplace l'extension par .c */
  947.         strcpy(rindex(fichier_sortie, '.'), ".c");
  948.         /* ouvre le fichier cree en ecriture */
  949.         fichier=fopen(fichier_sortie, "w");
  950.         /* Creation de la table de hachage */
  951.         table_variable=g_hash_table_new_full(g_str_hash,g_str_equal,NULL,free);
  952.         printf("Debut de l'analyse syntaxique :\n");
  953.         debut_code();
  954.         yyparse();
  955.         fin_code();
  956.         printf("Fin de l'analyse !\n");
  957.         printf("Resultat :\n");
  958.         if(error_lexical){
  959.                 printf("\t-- Echec : Certains lexemes ne font pas partie du lexique du langage ! --\n");
  960.                 printf("\t-- Echec a l'analyse lexicale --\n");
  961.         }
  962.         else{
  963.                 printf("\t-- Succes a l'analyse lexicale ! --\n");
  964.         }
  965.         if(error_syntaxical){
  966.                 printf("\t-- Echec : Certaines phrases sont syntaxiquement incorrectes ! --\n");
  967.                 printf("\t-- Echec a l'analyse syntaxique --\n");
  968.         }
  969.         else{
  970.                 printf("\t-- Succes a l'analyse syntaxique ! --\n");
  971.                 if(error_semantical){
  972.                         printf("\t-- Echec : Certaines phrases sont semantiquement incorrectes ! --\n");
  973.                         printf("\t-- Echec a l'analyse semantique --\n");
  974.                 }
  975.                 else{
  976.                         printf("\t-- Succes a l'analyse semantique ! --\n");
  977.                 }
  978.         }
  979.         /* Suppression du fichier genere si erreurs analyse */
  980.         if(error_lexical||error_syntaxical||error_semantical){
  981.                 remove(fichier_sortie);
  982.                 printf("ECHEC GENERATION CODE !\n");
  983.         }
  984.         else{
  985.                 printf("Le fichier \"%s\" a ete genere !\n",fichier_sortie);
  986.         }
  987.         /* Fermeture des flux */
  988.         fclose(fichier);
  989.         fclose(stdin);
  990.         /* Liberation memoire */
  991.         free(fichier_entree);
  992.         free(fichier_sortie);
  993.         g_hash_table_destroy(table_variable);
  994.         return EXIT_SUCCESS;
  995. }
  996.  
  997. void yyerror(char *s) {
  998.         fprintf(stderr, "Erreur de syntaxe a la ligne %d: %s\n", lineno, s);
  999. }
  1000.  
  1001. /* Cette fonction supprime dans la table de hachage toutes les variables declarees pour la premiere fois dans l'arbre syntaxique donne en parametre */
  1002.  
  1003. void supprime_variable(GNode* ast){
  1004.     /* si l'element n'est pas NULL et que ce n'est pas une feuille et que ce n'est pas un type bloc code (pour eviter de supprimer une variable deja suprimee) */
  1005.     if(ast&&!G_NODE_IS_LEAF(ast)&&(long)ast->data!=BLOC_CODE){
  1006.         /* si le noeud est de type declaration */
  1007.         if((long)ast->data==AFFECTATIONB||(long)ast->data==AFFECTATIONE||(long)ast->data==AFFECTATIONT||(long)ast->data==AFFECTATIOND){
  1008.             /* suppression de la variable dans la table de hachage */
  1009.             if(g_hash_table_remove(table_variable,(char*)g_node_nth_child(g_node_nth_child(ast,0),0)->data)){
  1010.                 printf("Variable supprimee !\n");
  1011.             }else{
  1012.                 fprintf(stderr,"ERREUR - PROBLEME DE SUPPRESSION VARIABLE !\n");
  1013.                 exit(-1);
  1014.             }
  1015.         /* sinon on continue de parcourir l'arbre */
  1016.         }else{
  1017.             int nb_enfant;
  1018.             for(nb_enfant=0;nb_enfant<=g_node_n_children(ast);nb_enfant++){
  1019.                 supprime_variable(g_node_nth_child(ast,nb_enfant));
  1020.             }
  1021.         }
  1022.     }
  1023. }
  1024.  
  1025. /* Cette fonction dit si un arbre contient un decimal */
  1026.  
  1027. bool decimal(GNode* ast){
  1028.     /* si l'element n'est pas NULL et que ce n'est pas une feuille et que ce n'est pas un type bloc code (pour eviter de supprimer une variable deja suprimee) */
  1029.     bool nbdecimal=false;
  1030.     if(ast&&!G_NODE_IS_LEAF(ast)){
  1031.         /* si le noeud est de type decimal */
  1032.         if((long)ast->data==DECIMAL){
  1033.             nbdecimal=true;
  1034.         /* si le noeud est une variable */
  1035.         }else if((long)ast->data==VARIABLE){
  1036.                 /* On recupere un pointeur vers la structure Variable */
  1037.                         Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child(ast,0)->data);
  1038.                         /* Si on a trouve un pointeur valable */
  1039.                         if(var!=NULL){
  1040.                                 /* On regarde si le type de la variable est un decimal */
  1041.                                 if(strcmp(var->type,"decimal")==0)
  1042.                                         nbdecimal=true;
  1043.                         }
  1044.         /* sinon on continue de parcourir l'arbre */
  1045.         }else{
  1046.             int nb_enfant;
  1047.             for(nb_enfant=0;nb_enfant<=g_node_n_children(ast);nb_enfant++){
  1048.                 nbdecimal|=decimal(g_node_nth_child(ast,nb_enfant));
  1049.             }
  1050.         }
  1051.     }
  1052.     return nbdecimal;
  1053. }

Bon maintenant vous savez qu'il faut ajouter les nouvelles options dans le générateur de code :

generation_code.c
  1.                         case DECIMAL:
  2.                                 fprintf(fichier,"%s",(char*)g_node_nth_child(ast,0)->data);
  3.                                 break;
  4.                         case AFFECTATIOND:
  5.                                 fprintf(fichier,"\tdouble ");
  6.                                 genere_code(g_node_nth_child(ast,0));
  7.                                 fprintf(fichier,"=");
  8.                                 genere_code(g_node_nth_child(ast,1));
  9.                                 fprintf(fichier,";\n");
  10.                                 break;
  11.                         case AFFICHAGED:
  12.                                 fprintf(fichier,"\tprintf(\"%%f\",");
  13.                                 genere_code(g_node_nth_child(ast,0));
  14.                                 fprintf(fichier,");\n");
  15.                                 break;

Et maintenant on teste :

programme.simple
  1. /* PI = 3.1415 */
  2.  
  3. d_PI = 3.141592;
  4.  
  5. afficher d_PI;
  6. afficher "\n";
  7.  
  8. e_PI = d_PI; //Caste automatique
  9.  
  10. afficher e_PI;
  11. afficher "\n";
  12.  
  13. afficher e_PI*d_PI; //Affiche un decimal (3*3.141592)
  14. afficher "\n";
  15.  
  16. afficher d_PI*d_PI; //Affiche un decimal (3.141592 au carre)
  17. afficher "\n";
  18.  
  19. <!--
  20.  
  21. AFFICHAGE DE LA TABLE DE MULTIPLICATION DE 1 A 10
  22.  
  23. -->
  24.  
  25. afficher "---------------------------------TABLE DE MULTIPLICATION---------------------------------\n";
  26. afficher "|X\t1\t2\t3\t4\t5\t6\t7\t8\t9\t10\t|\n";
  27. e_i=0;
  28. (10)x
  29.     e_j=0;
  30.     e_i++;
  31.     afficher "|";
  32.     afficher e_i;
  33.     (10)x
  34.         e_j++;
  35.         afficher "\t";
  36.         afficher e_i*e_j;
  37.     ;
  38.     e_j++;
  39.     afficher "\t|\n";
  40. ;
  41. afficher "-----------------------------------------------------------------------------------------\n";
  42.  
  43. <!--
  44.  
  45. AFFICHAGE DE LA TABLE DE DIVISION DE 1 A 10
  46.  
  47. -->
  48.  
  49. afficher "TABLE DE DIVISION\n";
  50. d_i=0;
  51. (10)x
  52.     d_j=0;
  53.     d_i++;
  54.     (10)x
  55.         d_j++;
  56.         afficher d_i/d_j;
  57.         afficher "\t";
  58.     ;
  59.     d_j++;
  60.     afficher "\n";
  61. ;

Et cela vous affiche après exécution :

3.141592
3
9.424776
9.869600
---------------------------------TABLE DE MULTIPLICATION---------------------------------
|X      1       2       3       4       5       6       7       8       9       10      |
|1      1       2       3       4       5       6       7       8       9       10      |
|2      2       4       6       8       10      12      14      16      18      20      |
|3      3       6       9       12      15      18      21      24      27      30      |
|4      4       8       12      16      20      24      28      32      36      40      |
|5      5       10      15      20      25      30      35      40      45      50      |
|6      6       12      18      24      30      36      42      48      54      60      |
|7      7       14      21      28      35      42      49      56      63      70      |
|8      8       16      24      32      40      48      56      64      72      80      |
|9      9       18      27      36      45      54      63      72      81      90      |
|10     10      20      30      40      50      60      70      80      90      100     |
-----------------------------------------------------------------------------------------
TABLE DE DIVISION
1.000000        0.500000        0.333333        0.250000        0.200000        0.166667        0.142857        0.125000        0.111111        0.100000
2.000000        1.000000        0.666667        0.500000        0.400000        0.333333        0.285714        0.250000        0.222222        0.200000
3.000000        1.500000        1.000000        0.750000        0.600000        0.500000        0.428571        0.375000        0.333333        0.300000
4.000000        2.000000        1.333333        1.000000        0.800000        0.666667        0.571429        0.500000        0.444444        0.400000
5.000000        2.500000        1.666667        1.250000        1.000000        0.833333        0.714286        0.625000        0.555556        0.500000
6.000000        3.000000        2.000000        1.500000        1.200000        1.000000        0.857143        0.750000        0.666667        0.600000
7.000000        3.500000        2.333333        1.750000        1.400000        1.166667        1.000000        0.875000        0.777778        0.700000
8.000000        4.000000        2.666667        2.000000        1.600000        1.333333        1.142857        1.000000        0.888889        0.800000
9.000000        4.500000        3.000000        2.250000        1.800000        1.500000        1.285714        1.125000        1.000000        0.900000
10.000000       5.000000        3.333333        2.500000        2.000000        1.666667        1.428571        1.250000        1.111111        1.000000

Voilà pour cette évolution. La prochaine évolution concernera les entrées (saisies utilisateurs).

<< Évolution 8 : Autres boucles for | Évolution 9 : Les nombres décimaux | Évolution 10 : Les entrées clavier >>

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

Page last modified on August 12, 2016, at 02:39 PM EST

This page has been requested 1068 times (Today : 1) - Total number of requests : 208042

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.