Recent Changes - Search:

My Projects

Courses

Writings

Source Code

Social Networks

Live Traffic !

Évolution 10 : Les entrées clavier

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

<< Évolution 9 : Les nombres décimaux | Évolution 10 : Les entrées clavier | Prochainement Évolution 11 >>

Nous allons mettre en place une nouvelle instruction Simple qui sera la saisie. Simple n'offre actuellement aucune interactivité avec l'utilisateur, il exécute bêtement un programme. Nous allons pallier à ce manque dans cette évolution. Nous allons pouvoir saisir au clavier, quand le programme nous le demande, une chaîne de caractère, un entier, un booléen ou encore un décimal (les 4 types natifs de Simple).

Évolution 10 du langage :

  1. <saisie> ::= "saisir" ( variable_decimale | variable_entiere | variable_texte | variable_booleenne ) ";"
  2.  
  3. <instruction> ::= <instruction> | <saisie>

On a un nouveau lexème "saisir" à faire connaître à l’analyseur lexical :

lexique_simple.lex
  1. "saisir"        {return TOK_SAISIR;}

Les possibilités de code dans le fichier d'entête :

simple.h
  1. #define SAISIEE             59
  2. #define SAISIEB             60
  3. #define SAISIED             61
  4. #define SAISIET             62
  5. #define SAISIENE            63
  6. #define SAISIENB            64
  7. #define SAISIEND            65
  8. #define SAISIENT            66

On a deux types de saisie pour chaque type natif de variable : Un pour affecter et un pour déclarer puis affecter si la variable n'a jamais été déclarée. On met à jour l'analyseur syntaxique :

syntaxe_simple.y
  1. %token                                  TOK_SAISIR              /* saisir */
syntaxe_simple.y
  1. instruction:    affectation{
  2.                         printf("\tInstruction type Affectation\n");
  3.                         $$=$1;
  4.                 }
  5.                 |
  6.                 affichage{
  7.                         printf("\tInstruction type Affichage\n");
  8.                         $$=$1;
  9.                 }
  10.                 |
  11.                 condition{
  12.                     printf("Condition si/sinon\n");
  13.                     $$=$1;
  14.                 }
  15.                 |
  16.                 boucle_for{
  17.                         printf("Boucle repetee\n");
  18.                         $$=$1;
  19.                 }
  20.                 |
  21.                 boucle_while{
  22.                         printf("Boucle tant que\n");
  23.                         $$=$1;
  24.                 }
  25.                 |
  26.                 boucle_do_while{
  27.                         printf("Boucle faire tant que\n");
  28.                         $$=$1;
  29.                 }
  30.                 |
  31.                 suppression{
  32.                         printf("\tInstruction type Suppression\n");
  33.                         $$=$1;
  34.                 }
  35.                 |
  36.                 saisie{
  37.                         printf("\tInstruction type Saisie\n");
  38.                         $$=$1;
  39.                 };
syntaxe_simple.y
  1. saisie:         TOK_SAISIR variable_texte TOK_FINSTR{
  2.                                 Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($2,0)->data);
  3.                                 if(var==NULL){
  4.                                                 /* On cree une Variable et on lui affecte le type que nous connaissons et la valeur */
  5.                                 var=malloc(sizeof(Variable));
  6.                                 if(var!=NULL){
  7.                                         var->type=strdup("texte");
  8.                                         var->value=NULL;
  9.                                         /* On l'insere dans la table de hachage (cle: <nom_variable> / valeur: <(type,valeur)>) */
  10.                                         if(g_hash_table_insert(table_variable,g_node_nth_child($2,0)->data,var)){
  11.                                         $$=g_node_new((gpointer)SAISIENT);
  12.                                         g_node_append($$,$2);
  13.                                         }else{
  14.                                             fprintf(stderr,"ERREUR - PROBLEME CREATION VARIABLE !\n");
  15.                                             exit(-1);
  16.                                         }
  17.                                 }else{
  18.                                         fprintf(stderr,"ERREUR - PROBLEME ALLOCATION MEMOIRE VARIABLE !\n");
  19.                                         exit(-1);
  20.                                 }
  21.                                 }else{
  22.                                         $$=g_node_new((gpointer)SAISIET);
  23.                                         g_node_append($$,$2);
  24.                                 }
  25.                         }
  26.                         |
  27.                         TOK_SAISIR variable_entiere TOK_FINSTR{
  28.                                 Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($2,0)->data);
  29.                                 if(var==NULL){
  30.                                                 /* On cree une Variable et on lui affecte le type que nous connaissons et la valeur */
  31.                                 var=malloc(sizeof(Variable));
  32.                                 if(var!=NULL){
  33.                                         var->type=strdup("entier");
  34.                                         var->value=NULL;
  35.                                         /* On l'insere dans la table de hachage (cle: <nom_variable> / valeur: <(type,valeur)>) */
  36.                                         if(g_hash_table_insert(table_variable,g_node_nth_child($2,0)->data,var)){
  37.                                         $$=g_node_new((gpointer)SAISIENE);
  38.                                         g_node_append($$,$2);
  39.                                         }else{
  40.                                             fprintf(stderr,"ERREUR - PROBLEME CREATION VARIABLE !\n");
  41.                                             exit(-1);
  42.                                         }
  43.                                 }else{
  44.                                         fprintf(stderr,"ERREUR - PROBLEME ALLOCATION MEMOIRE VARIABLE !\n");
  45.                                         exit(-1);
  46.                                 }
  47.                                 }else{
  48.                                         $$=g_node_new((gpointer)SAISIEE);
  49.                                         g_node_append($$,$2);
  50.                                 }
  51.                         }
  52.                         |
  53.                         TOK_SAISIR variable_booleenne TOK_FINSTR{
  54.                                 Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($2,0)->data);
  55.                                 if(var==NULL){
  56.                                                 /* On cree une Variable et on lui affecte le type que nous connaissons et la valeur */
  57.                                 var=malloc(sizeof(Variable));
  58.                                 if(var!=NULL){
  59.                                         var->type=strdup("booleen");
  60.                                         var->value=NULL;
  61.                                         /* On l'insere dans la table de hachage (cle: <nom_variable> / valeur: <(type,valeur)>) */
  62.                                         if(g_hash_table_insert(table_variable,g_node_nth_child($2,0)->data,var)){
  63.                                         $$=g_node_new((gpointer)SAISIENB);
  64.                                         g_node_append($$,$2);
  65.                                         }else{
  66.                                             fprintf(stderr,"ERREUR - PROBLEME CREATION VARIABLE !\n");
  67.                                             exit(-1);
  68.                                         }
  69.                                 }else{
  70.                                         fprintf(stderr,"ERREUR - PROBLEME ALLOCATION MEMOIRE VARIABLE !\n");
  71.                                         exit(-1);
  72.                                 }
  73.                                 }else{
  74.                                         $$=g_node_new((gpointer)SAISIEB);
  75.                                         g_node_append($$,$2);
  76.                                 }
  77.                         }
  78.                         |
  79.                         TOK_SAISIR variable_decimale TOK_FINSTR{
  80.                                 Variable* var=g_hash_table_lookup(table_variable,(char*)g_node_nth_child($2,0)->data);
  81.                                 if(var==NULL){
  82.                                                 /* On cree une Variable et on lui affecte le type que nous connaissons et la valeur */
  83.                                 var=malloc(sizeof(Variable));
  84.                                 if(var!=NULL){
  85.                                         var->type=strdup("decimal");
  86.                                         var->value=NULL;
  87.                                         /* On l'insere dans la table de hachage (cle: <nom_variable> / valeur: <(type,valeur)>) */
  88.                                         if(g_hash_table_insert(table_variable,g_node_nth_child($2,0)->data,var)){
  89.                                         $$=g_node_new((gpointer)SAISIEND);
  90.                                         g_node_append($$,$2);
  91.                                         }else{
  92.                                             fprintf(stderr,"ERREUR - PROBLEME CREATION VARIABLE !\n");
  93.                                             exit(-1);
  94.                                         }
  95.                                 }else{
  96.                                         fprintf(stderr,"ERREUR - PROBLEME ALLOCATION MEMOIRE VARIABLE !\n");
  97.                                         exit(-1);
  98.                                 }
  99.                                 }else{
  100.                                         $$=g_node_new((gpointer)SAISIED);
  101.                                         g_node_append($$,$2);
  102.                                 }
  103.                         };

Bien, on passe au plus difficile maintenant : la génération de code. Il faut éviter les dépassements de tampon (buffer overflow en anglais) en C. Pour ce faire, on alloue une zone de char de manière dynamique car on ne connaît pas à l'avance la longueur de la chaîne qui sera saisie. On commence par allouer une zone de 1 char. Puis à la saisie d'un nouvel caractère par l'utilisateur, on demande la réallocation dynamique et d'agrandir la taille d'un char. Et ce jusqu'à ce que l'utilisateur finit sa saisie en appuyant sur la touche Entrée. Cela donne en C ce code :

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <stdbool.h>
  5.  
  6. int main(int argc, char *argv[]) {
  7.     // on alloue une zone de char de 1 char
  8.     char* str=malloc(sizeof(char));
  9.     // caractere courant saisi
  10.     char c;
  11.     // nombre de caractere saisie
  12.     int i=0;
  13.     do{
  14.         // char lu
  15.         c=getchar();
  16.         str[i]=c;
  17.         // reallocation -> agrandit la taille de 1 char de plus
  18.         str=realloc(str,sizeof(char)*(i+2));
  19.         i++;
  20.     }while(c!='\n'); //jusqu'a ce que l'utilisateur appuie sur Entree
  21.     str[i-1]='\0'; //on tronque la chaine, on enleve le dernier caractere qui est le retour chariot '\n'
  22.     return EXIT_SUCCESS;
  23. }

Pour lire un double ou un entier, on va utiliser les fonctions C respectives strtod et strold qui caste la chaîne. Pour les booléens, si la chaîne saisie est égale à "vrai", "1" ou "true", alors ce sera vrai sinon faux. Voici le générateur de code :

generation_code.c
  1.                         case SAISIENT:
  2.                                 fprintf(fichier,"\tchar* ");
  3.                                 genere_code(g_node_nth_child(ast,0));
  4.                                 fprintf(fichier,";\n\tif((");
  5.                                 genere_code(g_node_nth_child(ast,0));
  6.                                 fprintf(fichier,"=malloc(");
  7.                                 fprintf(fichier,"sizeof(char)))==NULL){\n");
  8.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  9.                                 genere_code(g_node_nth_child(ast,0));
  10.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  11.                                 fprintf(fichier,"\t_esaisie=0;\n");
  12.                                 fprintf(fichier,"\tdo{\n");
  13.                                 fprintf(fichier,"\t_csaisie=getchar();\n\t");
  14.                                 genere_code(g_node_nth_child(ast,0));
  15.                                 fprintf(fichier,"[_esaisie]=_csaisie;\n");
  16.                                 fprintf(fichier,"\tif((");
  17.                                 genere_code(g_node_nth_child(ast,0));
  18.                                 fprintf(fichier,"=realloc(");
  19.                                 genere_code(g_node_nth_child(ast,0));
  20.                                 fprintf(fichier,",sizeof(char)*(_esaisie+2)))==NULL){\n");
  21.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  22.                                 genere_code(g_node_nth_child(ast,0));
  23.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  24.                                 fprintf(fichier,"\t_esaisie++;\n");
  25.                                 fprintf(fichier,"\t}while(_csaisie!='\\n');\n");
  26.                                 fprintf(fichier,"\t");
  27.                                 genere_code(g_node_nth_child(ast,0));
  28.                                 fprintf(fichier,"[_esaisie-1]='\\0';\n");
  29.                                 break;
  30.                         case SAISIET:
  31.                                 fprintf(fichier,"\tif((");
  32.                                 genere_code(g_node_nth_child(ast,0));
  33.                                 fprintf(fichier,"=realloc(");
  34.                                 genere_code(g_node_nth_child(ast,0));
  35.                                 fprintf(fichier,",sizeof(char)))==NULL){\n");
  36.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  37.                                 genere_code(g_node_nth_child(ast,0));
  38.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  39.                                 fprintf(fichier,"\t_esaisie=0;\n");
  40.                                 fprintf(fichier,"\tdo{\n");
  41.                                 fprintf(fichier,"\t_csaisie=getchar();\n\t");
  42.                                 genere_code(g_node_nth_child(ast,0));
  43.                                 fprintf(fichier,"[_esaisie]=_csaisie;\n");
  44.                                 fprintf(fichier,"\tif((");
  45.                                 genere_code(g_node_nth_child(ast,0));
  46.                                 fprintf(fichier,"=realloc(");
  47.                                 genere_code(g_node_nth_child(ast,0));
  48.                                 fprintf(fichier,",sizeof(char)*(_esaisie+2)))==NULL){\n");
  49.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  50.                                 genere_code(g_node_nth_child(ast,0));
  51.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  52.                                 fprintf(fichier,"\t_esaisie++;\n");
  53.                                 fprintf(fichier,"\t}while(_csaisie!='\\n');\n");
  54.                                 fprintf(fichier,"\t");
  55.                                 genere_code(g_node_nth_child(ast,0));
  56.                                 fprintf(fichier,"[_esaisie-1]='\\0';\n");
  57.                                 break;
  58.                         case SAISIENE:
  59.                                 fprintf(fichier,"\tif((_tsaisie");
  60.                                 fprintf(fichier,"=malloc(");
  61.                                 fprintf(fichier,"sizeof(char)))==NULL){\n");
  62.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  63.                                 genere_code(g_node_nth_child(ast,0));
  64.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  65.                                 fprintf(fichier,"\t_esaisie=0;\n");
  66.                                 fprintf(fichier,"\tdo{\n");
  67.                                 fprintf(fichier,"\t_csaisie=getchar();\n");
  68.                                 fprintf(fichier,"\t_tsaisie[_esaisie]=_csaisie;\n");
  69.                                 fprintf(fichier,"\tif((_tsaisie");
  70.                                 fprintf(fichier,"=realloc(_tsaisie");
  71.                                 fprintf(fichier,",sizeof(char)*(_esaisie+2)))==NULL){\n");
  72.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  73.                                 genere_code(g_node_nth_child(ast,0));
  74.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  75.                                 fprintf(fichier,"\t_esaisie++;\n");
  76.                                 fprintf(fichier,"\t}while(_csaisie!='\\n');\n");
  77.                                 fprintf(fichier,"\t_tsaisie");
  78.                                 fprintf(fichier,"[_esaisie-1]='\\0';\n");
  79.                                 fprintf(fichier,"\tlong ");
  80.                                 genere_code(g_node_nth_child(ast,0));
  81.                                 fprintf(fichier,"=strtold(_tsaisie,NULL);\n\tfree(_tsaisie);\n");
  82.                                 break;
  83.                         case SAISIEE:
  84.                                 fprintf(fichier,"\tif((_tsaisie");
  85.                                 fprintf(fichier,"=malloc(");
  86.                                 fprintf(fichier,"sizeof(char)))==NULL){\n");
  87.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  88.                                 genere_code(g_node_nth_child(ast,0));
  89.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  90.                                 fprintf(fichier,"\t_esaisie=0;\n");
  91.                                 fprintf(fichier,"\tdo{\n");
  92.                                 fprintf(fichier,"\t_csaisie=getchar();\n");
  93.                                 fprintf(fichier,"\t_tsaisie[_esaisie]=_csaisie;\n");
  94.                                 fprintf(fichier,"\tif((_tsaisie");
  95.                                 fprintf(fichier,"=realloc(_tsaisie");
  96.                                 fprintf(fichier,",sizeof(char)*(_esaisie+2)))==NULL){\n");
  97.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  98.                                 genere_code(g_node_nth_child(ast,0));
  99.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  100.                                 fprintf(fichier,"\t_esaisie++;\n");
  101.                                 fprintf(fichier,"\t}while(_csaisie!='\\n');\n");
  102.                                 fprintf(fichier,"\t_tsaisie[_esaisie-1]='\\0';\n\t");
  103.                                 genere_code(g_node_nth_child(ast,0));
  104.                                 fprintf(fichier,"=strtold(_tsaisie,NULL);\n\tfree(_tsaisie);\n");
  105.                                 break;
  106.                         case SAISIENB:
  107.                                 fprintf(fichier,"\tif((_tsaisie");
  108.                                 fprintf(fichier,"=malloc(");
  109.                                 fprintf(fichier,"sizeof(char)))==NULL){\n");
  110.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  111.                                 genere_code(g_node_nth_child(ast,0));
  112.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  113.                                 fprintf(fichier,"\t_esaisie=0;\n");
  114.                                 fprintf(fichier,"\tdo{\n");
  115.                                 fprintf(fichier,"\t_csaisie=getchar();\n");
  116.                                 fprintf(fichier,"\t_tsaisie[_esaisie]=_csaisie;\n");
  117.                                 fprintf(fichier,"\tif((_tsaisie");
  118.                                 fprintf(fichier,"=realloc(_tsaisie");
  119.                                 fprintf(fichier,",sizeof(char)*(_esaisie+2)))==NULL){\n");
  120.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  121.                                 genere_code(g_node_nth_child(ast,0));
  122.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  123.                                 fprintf(fichier,"\t_esaisie++;\n");
  124.                                 fprintf(fichier,"\t}while(_csaisie!='\\n');\n");
  125.                                 fprintf(fichier,"\t_tsaisie");
  126.                                 fprintf(fichier,"[_esaisie-1]='\\0';\n");
  127.                                 fprintf(fichier,"\tbool ");
  128.                                 genere_code(g_node_nth_child(ast,0));
  129.                                 fprintf(fichier,"=(strcmp(_tsaisie,\"vrai\")==0||strcmp(_tsaisie,\"true\")==0||strcmp(_tsaisie,\"1\")==0);\n\tfree(_tsaisie);\n");
  130.                                 break;
  131.                         case SAISIEB:
  132.                                 fprintf(fichier,"\tif((_tsaisie");
  133.                                 fprintf(fichier,"=malloc(");
  134.                                 fprintf(fichier,"sizeof(char)))==NULL){\n");
  135.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  136.                                 genere_code(g_node_nth_child(ast,0));
  137.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  138.                                 fprintf(fichier,"\t_esaisie=0;\n");
  139.                                 fprintf(fichier,"\tdo{\n");
  140.                                 fprintf(fichier,"\t_csaisie=getchar();\n");
  141.                                 fprintf(fichier,"\t_tsaisie[_esaisie]=_csaisie;\n");
  142.                                 fprintf(fichier,"\tif((_tsaisie");
  143.                                 fprintf(fichier,"=realloc(_tsaisie");
  144.                                 fprintf(fichier,",sizeof(char)*(_esaisie+2)))==NULL){\n");
  145.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  146.                                 genere_code(g_node_nth_child(ast,0));
  147.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  148.                                 fprintf(fichier,"\t_esaisie++;\n");
  149.                                 fprintf(fichier,"\t}while(_csaisie!='\\n');\n");
  150.                                 fprintf(fichier,"\t_tsaisie");
  151.                                 fprintf(fichier,"[_esaisie-1]='\\0';\n\t");
  152.                                 genere_code(g_node_nth_child(ast,0));
  153.                                 fprintf(fichier,"=(strcmp(_tsaisie,\"vrai\")==0||strcmp(_tsaisie,\"true\")==0||strcmp(_tsaisie,\"1\")==0);\n\tfree(_tsaisie);\n");
  154.                                 break;
  155.                         case SAISIEND:
  156.                                 fprintf(fichier,"\tif((_tsaisie");
  157.                                 fprintf(fichier,"=malloc(");
  158.                                 fprintf(fichier,"sizeof(char)))==NULL){\n");
  159.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  160.                                 genere_code(g_node_nth_child(ast,0));
  161.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  162.                                 fprintf(fichier,"\t_esaisie=0;\n");
  163.                                 fprintf(fichier,"\tdo{\n");
  164.                                 fprintf(fichier,"\t_csaisie=getchar();\n");
  165.                                 fprintf(fichier,"\t_tsaisie[_esaisie]=_csaisie;\n");
  166.                                 fprintf(fichier,"\tif((_tsaisie");
  167.                                 fprintf(fichier,"=realloc(_tsaisie");
  168.                                 fprintf(fichier,",sizeof(char)*(_esaisie+2)))==NULL){\n");
  169.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  170.                                 genere_code(g_node_nth_child(ast,0));
  171.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  172.                                 fprintf(fichier,"\t_esaisie++;\n");
  173.                                 fprintf(fichier,"\t}while(_csaisie!='\\n');\n");
  174.                                 fprintf(fichier,"\t_tsaisie");
  175.                                 fprintf(fichier,"[_esaisie-1]='\\0';\n");
  176.                                 fprintf(fichier,"\tdouble ");
  177.                                 genere_code(g_node_nth_child(ast,0));
  178.                                 fprintf(fichier,"=strtod(_tsaisie,NULL);\n\tfree(_tsaisie);\n");
  179.                                 break;
  180.                         case SAISIED:
  181.                                 fprintf(fichier,"\tif((_tsaisie");
  182.                                 fprintf(fichier,"=malloc(");
  183.                                 fprintf(fichier,"sizeof(char)))==NULL){\n");
  184.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  185.                                 genere_code(g_node_nth_child(ast,0));
  186.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  187.                                 fprintf(fichier,"\t_esaisie=0;\n");
  188.                                 fprintf(fichier,"\tdo{\n");
  189.                                 fprintf(fichier,"\t_csaisie=getchar();\n");
  190.                                 fprintf(fichier,"\t_tsaisie[_esaisie]=_csaisie;\n");
  191.                                 fprintf(fichier,"\tif((_tsaisie");
  192.                                 fprintf(fichier,"=realloc(_tsaisie");
  193.                                 fprintf(fichier,",sizeof(char)*(_esaisie+2)))==NULL){\n");
  194.                                 fprintf(fichier,"\tprintf(\"Erreur de reallocation memoire sur la variable ");
  195.                                 genere_code(g_node_nth_child(ast,0));
  196.                                 fprintf(fichier," !\");\n\texit(-1);\n\t}\n");
  197.                                 fprintf(fichier,"\t_esaisie++;\n");
  198.                                 fprintf(fichier,"\t}while(_csaisie!='\\n');\n");
  199.                                 fprintf(fichier,"\t_tsaisie[_esaisie-1]='\\0';\n\t");
  200.                                 genere_code(g_node_nth_child(ast,0));
  201.                                 fprintf(fichier,"=strtod(_tsaisie,NULL);\n\tfree(_tsaisie);\n");
  202.                                 break;

J'ai changé la fonction debut_code() du générateur pour déclarer les variables temporaires relatives à la saisie :

generation_code.c
  1. void debut_code(){
  2.         fprintf(fichier, "/* FICHIER GENERE PAR LE COMPILATEUR SIMPLE */\n\n");
  3.         fprintf(fichier, "#include<stdlib.h>\n#include<stdbool.h>\n#include<stdio.h>\n#include<string.h>\n\n");
  4.         fprintf(fichier, "int _esaisie;\n");
  5.         fprintf(fichier, "char _csaisie;\n");
  6.         fprintf(fichier, "char* _tsaisie;\n\n");
  7.         fprintf(fichier, "int main(void){\n");
  8. }

Je vous donne un programme pour tester les différentes saisies clavier que l'on peut faire. Il s'agit d'un simple programme qui calcule l'IMC :

programme.simple
  1. afficher "Programme de calcul de l'IMC\n";
  2. b_Correct=faux;
  3. faire
  4.     afficher "Votre nom : ";
  5.     saisir t_Nom;
  6.     afficher "Votre prénom : ";
  7.     saisir t_Prenom;
  8.     afficher "Votre âge : ";
  9.     saisir e_Age;
  10.     afficher "Votre taille (en m) : ";
  11.     saisir d_Taille;
  12.     afficher "Votre poids (en kg) : ";
  13.     saisir d_Poids;
  14.     afficher "Etes-vous un homme ? (si oui, répondez vrai, 1 ou true) ";
  15.     saisir b_Sexe;
  16.     (b_Sexe)?
  17.         afficher "Bonjour M. ";
  18.     :
  19.         afficher "Bonjour Mme ";
  20.     ;
  21.     afficher t_Nom;
  22.     afficher " ";
  23.     afficher t_Prenom;
  24.     afficher ", vous avez ";
  25.     afficher e_Age;
  26.     afficher " ans, vous mesurez ";
  27.     afficher d_Taille;
  28.     afficher "m et pesez ";
  29.     afficher d_Poids;
  30.     afficher "kg. Votre IMC est de : ";
  31.     afficher d_Poids/(d_Taille*d_Taille);
  32.     afficher "kg/m².\n";
  33.     afficher "Est-ce correct ? (si oui, répondez vrai, 1 ou true) ";
  34.     saisir b_Correct;
  35.     supprimer t_Nom;
  36.     supprimer t_Prenom;
  37. ?(non b_Correct);

Avec ce que j'ai saisi, cela donne pour moi :

Programme de calcul de l'IMC
Votre nom : TRIBUTSCH
Votre prénom : Thomas
Votre âge : 23
Votre taille (en m) : 182
Votre poids (en kg) : 79
Etes-vous un homme ? (si oui, répondez vrai, 1 ou true) oui
Bonjour Mme TRIBUTSCH Thomas, vous avez 23 ans, vous mesurez 182.000000m et pesez 79.000000kg. Votre IMC est de : 0.002385kg/m².
Est-ce correct ? (si oui, répondez vrai, 1 ou true) non
Votre nom : TRIBUTSCH
Votre prénom : Thomas
Votre âge : 23
Votre taille (en m) : 1.82
Votre poids (en kg) : 79
Etes-vous un homme ? (si oui, répondez vrai, 1 ou true) 1
Bonjour M. TRIBUTSCH Thomas, vous avez 23 ans, vous mesurez 1.820000m et pesez 79.000000kg. Votre IMC est de : 23.849777kg/m².
Est-ce correct ? (si oui, répondez vrai, 1 ou true) 1

Voilà pour cette évolution qui rend désormais les programmes Simple un peu plus interactifs. La prochaine sera assez complexe je pense, on fera de la structure de données où on implémentera les tableaux.

<< Évolution 9 : Les nombres décimaux | Évolution 10 : Les entrées clavier | Prochainement Évolution 11 >>

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

Page last modified on August 13, 2016, at 03:54 PM EST

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

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.