Erreur de segmentation (Flex/Bison)

bonsoir !!
voila je desire réaliser un analyseur avec flex et bison
j'ai une erreure de segmentation a l'execution de la ligne 42 du fichier bison voici mes codes :
FLEX :

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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
%{
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "bis.tab.h"
int yyerror (char*); 
int nbrligne=1;
 
typedef struct elem * liste;
 
typedef struct elem{
 char *entite;
 char *type;
 int ligneA; 
 liste svt;
}elem;
 
liste table_symboles = NULL;
 
/*recherche*/
liste recherche(char *entite) {
 
liste p;
 
/* recherche dans la table des symboles */
p = table_symboles;
while (p) {
if ( strcmp( p->entite,entite)==0)
{ printf("Variable '%s' deja declarée à la linge %d\n", entite ,p->ligneA);
return p;
}
p = p->svt;
}
return NULL;
}
/*verification*/
void verif(char *entite){
liste p= recherche(entite);
if (p==NULL)
printf("IDENT INCONNU:%s",entite);
else
printf("IDENT CONNU:%s",entite);
}
/*insert*/
void insert(char *entite,char *type){
liste p= recherche(entite);
/* creation d'un noeud */
if (p == NULL) {
p = (liste) malloc(sizeof(elem));
strncpy(p->entite, entite, 32);
p->entite[31] = '\0'; /* si strlen(entite) > 31 */
strcpy(p->type,type);
p->ligneA=nbrligne;
p->svt=NULL;
 
/* insertion du noeud en tête de liste (LIFO) */
p->svt = table_symboles;
table_symboles = p;
}
}
/*affichage*/
void afficherts(){
	liste p = table_symboles;
	printf("table\n");
	while(p != NULL){
		printf("idf: %s type: %s declaré en ligne :%d",p->entite, p->type,p->ligneA);
		printf("\n");
		p = p->svt;	
	}
}
%}
lettre [a-zA-Z]
chiffre [0-9]
IDF  (({lettre}+)({lettre}*|{chiffre}*|(-?))({lettre}+|{chiffre}+))
constE ({chiffre}+)
SI "si"
SINON "sinon"
constR {chiffre}"."?{chiffre}+
 
 
CHAINE ["](.)+["]
coms  [#](.)+
 
type "INT"|"REAL"|"BOOLEAN"|"CHAR"
mot_cle {type}|"START"|"END"|"CODE"|"si"|"sinon"
%%
[\b\t];
{SI}+" "+{SINON}+" "+{IDF} {printf("si***ligne%d***condition attendue\n",nbrligne); }
{SI}+" "+{IDF}+" "+{SINON} {printf("sinon***ligne%d***condition attendue\n",nbrligne);}
{SI} {printf("MCLEF:%s\n",yytext); return (IF);}
{SINON} {printf("MCLEF:%s\n",yytext); return (ELSE);}
"INT"   return (INT);
"REAL" return (REAL);
"BOOLEAN" return (BOOLEAN);
"STRING" return (STRING);
"CHAR" return (CHAR);
"," return(VERGULE);
";" return(POINTVERGULE);
"=" return (EGAL);
"<>" return (DIFF);
":=" return(AFFECT);
"." return (POINT);
"CODE" return(CODE);
"START" return(START);
"END" return(END);
"CONST" return (CONST);
"WHILE" return (WHILE);
"EXECUTE" return (EXECUTE);
"WHENE" return (WHENE);
"DO" return (DO);
"OTHERWISE" return (OTHERWISE);
"+" {printf(" ADD:%s\n",yytext); return (SOM);}
"-" {printf(" SUB:%s\n",yytext); return (SOUS);}
"*" {printf(" MUL:%s\n",yytext); return (MUL);}
"/" {printf(" DIV:%s\n",yytext); return (DIV);}
["](.)+[^"] {printf("oh chaine non terminé ***ligne %d****fin de chaine attendue",nbrligne);} 
{CHAINE}   {printf(" CHAINE:%s\n",yytext);}
{lettre}   {printf("IDENT:%s\n",yytext); return (IDF);}
{lettre}-  {printf("erreur ligne %d :un idf ne se termine pas par -\n",nbrligne);}
{IDF}      {printf("IDENT:%s\n",yytext); return (IDF) ;}
{IDF}-     {yyerror("erreur :un idf ne se termine pas par -\n");}
{constE}   {printf("ENTIER:%s\n",yytext); return (CONSTE);}
 
{constR}   {printf("REEL:%s\n",yytext); return (CONSTR);}
 
{coms} {printf(" COMMENTAIRE:ON IGNORE\n"); return (COMS);}
"-"{IDF} {printf("-****ligne%d*****nombre attendu \n",nbrligne);}
"+"{IDF} {printf("-****ligne%d*****nombre attendu \n",nbrligne);}
{constE}"+" {printf("+****ligne%d*****deuxiéme opérande attendu \n",nbrligne);}  
{constR}"+" {printf("+****ligne%d*****deuxiéme opérande attendu \n",nbrligne);} 
{constE}"-" {printf("-****ligne%d*****deuxiéme opérande attendu \n",nbrligne);}  
{constR}"-" {printf("-****ligne%d*****deuxiéme opérande attendu \n",nbrligne);}   
[\n] nbrligne++;
~ { yyterminate();}
%%
 
int yywrap()
{
return 1;
}
int yyerror ( char* m ) {
printf ( "%s\n", m );
return 2;
}

BISON:

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
%{
#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
%}
%token IF
%token ELSE
%token CODE
%token START
%token IDF
%token END
%token INT
%token REAL
%token BOOLEAN
%token CHAR
%token STRING
%token CONST
%token WHILE 
%token EXECUTE
%token WHENE
%token DO
%token OTHERWISE
%token AFFECT
%token EGAL
%token DIFF
%token POINTVERGULE
%token VERGULE
%token POINT
%token CONSTE
 
%token CONSTR
 
%token COMS
%token SOM
%token SOUS
%token MUL
%token DIV
%%
PGME:CODE IDF partie_principal END POINT  {printf("Fin de compilation ��enjoy��");};
partie_principal:partie_declaration START PARTIEINST  ;
type:INT|BOOLEAN|CHAR|STRING|REAL ;
partie_declaration:type IDF B A{insert($2,$1);}|CONST IDF EGAL CONSTANTE A {insert($2,"");} | ;
B:C IDF B {insert($2,"");}|;
C:VERGULE;
CONSTANTE :CONSTE|CONSTR ;
PARTIEINST: IDF  AFFECT expression A{verif($1);}|WHENE cond EXECUTE inst A|WHENE cond DO PARTIEINST OTHERWISE PARTIEINST|IF cond expression ELSE cond expression A ;
expression :IDF{verif($1);}|IDF SOM IDF{verif($1); verif($3);}|IDF SOUS IDF{verif($1); verif($3);}|IDF MUL IDF{verif($1); verif($3);}|IDF DIV IDF{verif($1); verif($3);} ;
A :POINTVERGULE ;
cond:IDF EGAL IDF{verif($1);verif($3);}|IDF DIFF IDF {verif($1); verif($3);}|IDF  EGAL CONSTANTE{verif($1);} |IDF DIFF CONSTANTE {verif($1);}  ;
inst:PARTIEINST ;
%%
int main (void) {
yyparse ();
afficherts();
return 0 ;
}

merci de m'aider a résoudre cette erreure !!