Compilation , Yacc , Lex et boucle
Bonjours,
Je me retrouve confronté a un problème dans l'écriture d'une mini calculette en C avec yacc/flex , si une calculette qui ressemble a celles présenté dans le man de bison, nous arrivons ( mon binôme et moi ) a faire
- une gestion simple des variable ( comme c'est une calculette on s'arrette au double )
- a faire des calcul simple avec priorité.
- a faire des condition et un SI.
- a retourné les erreur.
Mais je bloque vraiment sur la boucle, puisque l'analyseur analyse la fin de l'arbre avent le neud sur le quel on se trouve ( dans le Yacc )
Dans le man de lex et de bison il oriante le lecteur vers un AST (Arbre syntaxique abstrait).
Je me suis donc dit qu'il fallais construire un de ces arbre a chaque fois que l'on rencontre une boucle dans le flex puis bouclé le nombre de fois voulue sur cet arbre en envoilent les token au yacc.
Sauf que c'est le Yacc qui appelle l'analyseur sytaxique de temps en temps et non pas l'analyse qui envoie ces token quand il veux au yacc. Je me retrouve donc coincé.
Notre code resemle a seci :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
| %{
#include "var2.h"
#include <string.h>
%}
CHIFFRE [0-9]
NUM ({CHIFFRE}*(\.{CHIFFRE}+)?)(e[+\-]{CHIFFRE}+)?
%%
[a-z]+ { struct Variable * ptr;
ptr = chercher_var(yytext);
if(ptr != NULL) {
yylval.pointeur = ptr;
return(VAR);
}
else {
yylval.pointeur = ajout_var(yytext);
return(VAR);
}
}
{NUM} {yylval.valeur = atof(yytext);
return(NOMBRE);}
\:= {return(AFFECT);}
\; {return(';');}
\+ {return('+');}
\* {return('*');}
\- {return('-');}
\/ {return('/');}
\( {return('(');}
\) {return(')');}
\n {return('\n');}
\ET {return(ET);}
\OU {return(OU);}
\= {return('=');}
\<= {return(INFEGAL);}
\< {return(INF);}
\>= {return(SUPEGAL);}
\> {return(SUP);}
\SI {return(SI);}
\ALORS {return(ALORS);}
\FINSI {return(FINSI);}
\POUR {return(POUR);}
\DE {return(DE);}
\A {return(A);}
\FAIRE {return(FAIRE);}
\FINPOUR {return(FINPOUR);}
.
%% |
et pour le yacc
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
| %{
#include <stdio.h>
#include <string.h>
#include "../FLEX/var2.h"
%}
%union{
double valeur;
struct Variable * pointeur;
}
%token <pointeur> VAR
%type <valeur> expr
%token <valeur> NOMBRE
%left ';' '\n'
%left AFFECT
%left '+' '-'
%left '*' '/'
%left ET OU
%left '=' INFEGAL INF SUPEGAL SUP
%left SI ALORS FINSI POUR DE A FAIRE FINPOUR
%nonassoc MOINSUNAIRE
%%
ligne : ligne expr '\n' {printf("resulat : %.4lf \n" , $2);}
| ligne '\n'
| ;
expr : expr '+' expr {$$ = $1 + $3 ;}
| expr '-' expr {$$ = $1 - $3 ;}
| expr '*' expr {$$ = $1 * $3 ;}
| expr '/' expr {$$ = $1 / $3 ;}
| '(' expr ')' {$$ = $2 ;}
| '-' expr %prec MOINSUNAIRE { $$ = -$2;}
| expr ET expr { $$ = $1 && $3 ;}
| expr OU expr { $$ = $1 || $3 ;}
| expr '=' expr { $$ = $1 == $3 ;}
| expr INFEGAL expr { $$ = $1 <= $3 ;}
| expr INF expr { $$ = $1 < $3 ;}
| expr SUPEGAL expr { $$ = $1 >= $3 ;}
| expr SUP expr { $$ = $1 > $3 ;}
| VAR AFFECT expr { $1->valeur = $3;$$ = $3;}
| NOMBRE
| VAR { $$ = $1->valeur;puts( $1->nom);}
| expr ';' '\n' expr
| SI expr ALORS expr FINSI { if($2)
{$$ = $4;} }
| SI expr ALORS '\n' expr '\n' FINSI { if($2)
{$$ = $5;} }
| POUR VAR DE expr A expr FAIRE expr FINPOUR {
$2->valeur = $4 ;
printf("valeur %lf\n" , $$);
}
;
%%
#include "../FLEX/calculetteEvoluee.c"
main(int argc , char ** argv){
if(argc > 1 ) {
yyin = fopen(argv[1], "r");
}
else {
yyin = stdin;
}
yyparse();
} |
Donc si quel qu'un connais une solution simple je l'en remercierait de m'en informé ^^
