utilisation de bison et flex en c++

salut =E0 tous !
voil=E0 mon probl=E8me, pour notre projet de fin de semestre en master
informatique, nous devons par groupe de 8 cr=E9er un compilateur /
interpr=E8teur d'un langage appel=E9 minijaja dont la grammaire peut
=EAtre consult=E9e ici :
http://lifc.univ-fcomte.fr/~bouquet/Enseignement/Compilation/minijaja.html

nous avions le choix entre l'utilisation d'un parser javaCC / jjTree ou
Flex et Bison. C'est sur ce deuxi=E8me =E9l=E9ment que s'est port=E9 notre
choix : nous utilisons donc Flex et Bison sous un environnement Linux.

voici le contenu de mon fichier utilis=E9 par Flex : terminaux.l
Code:
%{

#include "terminaux.tab.h"
extern int yylval;

%}

%x COMMENTS

%%

"class" { return CLASS; }
"{" { return BEGINBLOCK; }
"}" { return ENDBLOCK; }
"=3D=3D" { return EQUAL; }
"=3D" { return ASSIGN; }
"!" { return NOT; }
"+=3D" { return PLUSEQUAL; }
";" { return SEMICOLON; }
"[" { return LEFTBRACKET; }
"]" { return RIGHTBRACKET; }
"final" { return FINAL; }
")" { return RIGHTPARENTHESE; }
"(" { return LEFTPARENTHESE; }
"main" { return MAIN; }
"," { return COMMA; }
"++" { return PLUSPLUS; }
"return" { return RETURN; }
"if" { return IF; }
"else" { return ELSE; }
"while" { return WHILE; }
"-" { return MINUS; }
"&&" { return AND; }
"||" { return OR; }
">" { return GREATER; }
"+" { return PLUS; }
"*" { return MULT; }
"/" { return DIVIDE; }
"true" { return TRUE; }
"false" { return FALSE; }
"void" { return VOID; }
"int" { return INTEGER; }
"boolean" { return BOOLEAN; }
[0-9]+ { /*yylval =3D atoi(yytext);*/ return NUMBER; }
[a-zA-Z_][0-9a-zA-Z_]* { return IDENTIFIER; }
[ \t]+ { ; /* espaces vierges */ }
(\r?\n) { ; /* ligne vide : reconnait les CR-LF
(windows) et les LF (unix) */ }
"//".*\n { ; /* commentaires */ }

"/*" { BEGIN COMMENTS; }
<COMMENTS>. |
<COMMENTS>\n { ; }
<COMMENTS>"*/" { BEGIN 0; }
. { /*yyerror("illegal token");*/ }

%%


voici le contenu de mon fichier utilis=E9 par Bison : terminaux.y
Code:
%{

#include <stdio.h>

void yyerror(char * msg) {
fprintf(stderr, "%s\n", msg);
}

%}

/* l'element par lequel commence l'analyse,
ce ne doit pas etre un token */
%start root

%token CLASS
%token BEGINBLOCK
%token ENDBLOCK
%token EQUAL
%token ASSIGN
%token NOT
%token PLUSEQUAL
%token SEMICOLON
%token LEFTBRACKET
%token RIGHTBRACKET
%token FINAL
%token RIGHTPARENTHESE
%token LEFTPARENTHESE
%token MAIN
%token COMMA
%token PLUSPLUS
%token RETURN
%token IF
%token ELSE
%token WHILE
%token MINUS
%token AND
%token OR
%token GREATER
%token PLUS
%token MULT
%token DIVIDE
%token TRUE
%token FALSE
%token VOID
%token INTEGER
%token BOOLEAN
%token NUMBER
%token IDENTIFIER

%%

root:
classe
;

classe:
CLASS ident BEGINBLOCK decls methmain ENDBLOCK
;

ident:
IDENTIFIER
;

decls:

| decl SEMICOLON decls
;

decl:
var
| methode
;

vars:

| var SEMICOLON vars
;

var:
typemeth ident vexp
| typemeth ident LEFTBRACKET exp RIGHTBRACKET
| FINAL type ident vexp
;

vexp:

| ASSIGN exp
;

methode:
typemeth ident LEFTPARENTHESE entetes RIGHTPARENTHESE
BEGINBLOCK vars instrs ENDBLOCK
;

methmain:
MAIN BEGINBLOCK vars instrs ENDBLOCK
;

entetes:

| entete COMMA entetes
| entete
;

entete:
type ident
;

instrs:

| instr SEMICOLON instrs
;

instr:
ident1 ASSIGN exp
| ident1 PLUSEQUAL exp
| ident1 PLUSPLUS
| ident LEFTPARENTHESE listexp RIGHTPARENTHESE
| RETURN exp
| IF exp BEGINBLOCK instrs ENDBLOCK
| IF exp BEGINBLOCK instrs ENDBLOCK ELSE BEGINBLOCK
instrs ENDBLOCK
| WHILE exp BEGINBLOCK instrs ENDBLOCK
;

listexp:

| exp COMMA listexp
| exp
;

exp:
NOT exp1
| MINUS exp1
| exp AND exp1
| exp OR exp1
| exp1
;

exp1:
exp1 EQUAL exp2
| exp1 GREATER exp2
| exp2
;

exp2: exp2 PLUS terme
| exp2 MINUS terme
| terme
;

terme:
terme MULT fact
| terme DIVIDE fact
| fact
;

fact:
ident1
| ident LEFTPARENTHESE listexp RIGHTPARENTHESE
| TRUE
| FALSE
| NUMBER
| LEFTPARENTHESE exp RIGHTPARENTHESE
;

ident1:
ident
| ident LEFTBRACKET exp RIGHTBRACKET
;

typemeth:
VOID
| type
;

type:
INTEGER
| BOOLEAN
;

%%

main() {
yyparse();
}


voici les commandes que j'ex=E9cute pour tester la grammaire :
Code:
~/compil2 $ flex terminaux.l && bison -d terminaux.y
~/compil2 $ gcc -o test lex.yy.c terminaux.tab.c -ll
~/compil2 $ ./test
class C {
/* un commentaire
* sur plusieurs lignes.
*/

int x =3D 2;
int y =3D 3;

int somme(int a, int b) {
return x + y;
};

main {
int z =3D somme(x, y);
}

}
~/compil2 $


comme vous pouvez le voir, la g=E9n=E9ration de l'analyseur s'effectue
tr=E8s bien en C. seulement, notre projet doit utiliser du C++, c'est
une contrainte du cahier des charges. Est il possible de cr=E9er cet
analyseur en C++ depuis Flex et Bison ? j'ai vaguement entendu parler
de Flex++ et Bison++, est une bonne solution ?

Nous devrons stocker l'arbre syntaxique, et pour cela notre structure
(en cours de d=E9veloppement) sera faite en C++. J'avais =E9ventuellement
pens=E9 =E0 appeler les fonctions de cr=E9ation de la structure (C++)
depuis l'analyseur (C). Est ce possible ?

avez vous d=E9j=E0 utilis=E9 ces outils ? que me conseillez vous ?
J'esp=E8re que vous pourrez m'aider car c'est tr=E8s important, sans cet
analyseur, nous ne pourrons pas avancer dans notre projet.
Merci