LEX ne transmet rien a YACC

Bonjour

pour un projet d'ecole je doit realiser un analyseur lexical avec les outils LEX et YACC.
a la compil tout se passe bien mais quand je lance l'appli LEX reconnait bien les tokens que je charche (tester avec un printf) mais apparement lors de la transimssion du resultat a YACC ca ne marche pas, mes commandes ne sont pasq reconnue.

le code LEX :

%{
#include "projet.h"
#include "poly.h"
#include "projet.tab.h"

extern YYSTYPE yylval;

%}


%%
[0-9]+                    {yylval.entier = atoi(yytext); return INT; }
[0-9]*\.+[0-9]*         {yylval.reel = atof(yytext); return FLOAT; }
[A-Z]                    {yylval.var = (yytext[0]); return MAJ; }
"+"                        {return PLUS; }
"-"                        {return MOIN; }
"*"                        {return MULT; }
"/"                        {return DIV; }
"("                        {return PG; }
")"                        {return PD; }
\n                        {return FL; }
":="                    {return AFFECTE; }
":"                        {return OF; }
"="                        {return EGAL; }
[a-z]                    {yylval.var = (yytext[0]); return VARIABLE; }
"affiche"                {return AFFICHE; }
"^"                        {return HAUT; }
([a-z]*[A-Z]*)*            {yylval.string = (char *)malloc(strlen(yytext)+1);
                         strcpy(yylval.string, yytext);return CHAINE; }
%%

le code YACC :

%{

#include <stdio.h>

#include "projet.h"
#include "poly.h"

%}

%token FL VARIABLE OF PG PD AFFECTE PLUS MOIN MULT DIV EGAL INT FLOAT AFFICHE MAJ HAUT CHAINE

%union{
    var_liste l;
    struct monome *m;
    struct inconnue *inc;
    int entier;
    double reel;
    poly p;
    char var;
    char* string;
    struct expr {
        int type;
        union {
            char* string;
            double reel;
            int entier;
            poly p;
        };*/
    } expr;           
}

%type <var> VARIABLE MAJ
%type <entier> INT
%type <reel> FLOAT arith fact terme
%type <m> monome
%type <p> poly
%type <inc> var
%type <l> liste
%type <expr> expr
%type <string> CHAINE

%start S

%left PLUS MOIN
%left MULT DIV


%%
S:    NL
 |    VARIABLE OF INT NL                    { printf("%c : %i\n",$1,$3);DeclareVariable($1,$3); }
 |    AFFICHE PG liste PD    NL                { }
 |    VARIABLE AFFECTE expr NL            { switch ($3.type) {
                                              case ENTIER: setEntier($1,$3.entier); break;
                                              case REEL: setReel($1,$3.reel); break;
                                              case BOOL: setEntier($1,$3.entier); break;
                                              case POLYNOME: setPoly($1,$3.p); break;
                                              case STRING: setString($1,$3.string);
                                          }
                                        }   
 ;

liste:    VARIABLE liste                     { $$ = NULL; }       
     |    VARIABLE                        { $$ = NULL; }
     ;   
   
NL:    FL                                    { printf("FL\n"); }
  ;

expr:    poly PLUS poly                    { $$.type = POLYNOME; $$.p = SommePoly($1,$3); }
    |    poly MOIN poly                    { $$.type = POLYNOME; $$.p = SoustrairePoly($1,$3); }
    |    poly MULT poly                    { $$.type = POLYNOME; $$.p = MultiplierPoly($1,$3); }
    |    poly EGAL poly                    { $$.type = BOOL; $$.entier = PolyCmp($1,$3); }
    |    poly                            { $$.type = POLYNOME; $$.p = $1; }
    |    arith                            { $$.type = REEL; $$.reel = $1; }
    |    CHAINE                            { $$.type = STRING; strcpy($$.string, $1); }
    ;
   
arith:    INT                                { $$ = $1; }
     |    FLOAT                            { $$ = $1; }
     |    VARIABLE                        { switch (GetVarType($1)) {
                                              case ENTIER: $$ = table[$1 - 'a'].entier; break;
                                               case FLOAT: $$ = table[$1 - 'a'].reel; break; } }
     |    PG arith PD                        { $$ = $2; }
     |    MOIN arith                        { $$ = -$2 }
     |    arith PLUS arith                { $$ = $1 + $3; }
     |    arith MOIN arith                { $$ = $1 - $3; }
     |    arith MULT arith                { $$ = $1 * $3; }
     |    arith DIV arith                    { $$ = $1 / $3; }    
     ;
   
poly:     poly PLUS monome                 { $$ = AjouterMonome($1,$3); }
    |    poly MOIN monome                { $3->coef = -$3->coef; $$ = AjouterMonome($1,$3); }
    |    monome                            { $$ = $1; }
    ;
   
monome:    FLOAT var                        { $$ = newMonome($1, $2); }
      |    FLOAT                            { $$ = newMonome($1, NULL); }
      | INT                                { $$ = newMonome($1, NULL); }
      ;

var:     MAJ HAUT INT var                { $$ = AjouterIncTete($4, newInconnue($1,$3)); }
   |    MAJ HAUT INT                    { $$ = newInconnue($1,$3); }
   ;

%%

/*int main()
{
    InitTable();
    yyparse();
}*/
int yyerror(char *s)
{
    fprintf(stderr, "%s\n", s);
}

Par exemple:
je tape "a:2" et lui doit me repondre (par la fonction de declaration) que j'ai bien declarer la variable de type reel alors que la rien ne se passe.

Si quelqu'un a une idée je suis preneur car la je cherche depuis un bout de temp et ca commence a me faire ...

Merci.