Besoin d'aide Bison/C

Bonjour à tous,

Je viens de découvrir un parser de code c# développé avec Bison, il fonctionne parfaitement mais je ne suis pas encore à l'aise avec ce type de logiciel.
Le code plus bas me permet de parser ce code:
Code:

1 2 3 4 5 public class Hello { }
Ma question est, comment puis-je récupérer la valeur "Hello" de la section "class_declaration" (sachant que le code généré est en C) ?
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 attributes_opt : | attributes ; modifiers_opt : | modifiers ; modifiers : modifier | modifiers modifier ; modifier : ABSTRACT | EXTERN | INTERNAL | NEW | OVERRIDE | PRIVATE | PROTECTED | PUBLIC | READONLY | SEALED | STATIC | UNSAFE | VIRTUAL | VOLATILE ; comma_opt : | ';' ; class_declaration : attributes_opt modifiers_opt CLASS IDENTIFIER class_base_opt class_body comma_opt ; class_base_opt : | class_base ; class_base : ':' class_type | ':' interface_type_list | ':' class_type COMMA interface_type_list ; class_body : '{' class_member_declarations_opt '}' ;
Je vous remercie d'avance pour votre réponse,
Cordialement,
Nicolas.

Bonjour,

En vis-à-vis de chaque ligne, à côté de tes règles, tu peux ajouter un bloc de C entre accolades qui sera exécuté chaque fois que la ligne concernée aura été complètement reconnue. Tu peux utiliser, au sein de ton code, les jokers « $$ » pour la valeur de retour (donc de la règle entière) et « $1 », « $2 », etc. Pour connaître la valeur individuelle de chaque paramètre au sein de ta règle.

Attention, c'est du C : cela signifie qu'il te faudra peut-être gérer les problèmes de types. Pour cela, tu peux utiliser « %union » en début de fichier pour déclarer une union qui contiendra tous les types possibles et « %token<nomdumembre> » pour associer chaque lexon à un membre de l'union en particulier.

Bonjour Obsidian,

Merci pour ta réponse, en fait, j'avais essayé de remplacer la ligne par:
Code:

1 2 3 4 class_declaration : attributes_opt modifiers_opt CLASS IDENTIFIER class_base_opt class_body comma_opt {printf("Classe trouvée: %s\n", $3);} ;
mais ça me retourne:

Classe trouvée: (null)

J'ai essayé plusieurs valeurs ($1, $2, etc...) mais ça ne change rien...
Une idée ?

Cordialement,
Nicolas.

Où définis-tu « CLASS » ?

Je le déclare comme ça dans le fichier bison:

%token CLASS

Et voici le fichier lexer:

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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
%{
#include <string.h>
#include "csharp.tab.h"
 
  void lexical_error(const char *);
  static int token_for(const char *);
  static int is_allowed_char(const char );
%}
 
%option noyywrap
%option yylineno
%option stack
 
single_line_comment    "//".*
 
white_space            [ \t\n\r]
 
preprocessor           ^[ \t]*#.*
 
dec_digit              [0-9]
hex_digit              [0-9A-Fa-f]
int_suffix             [UuLl]|[Uu][Ll]|[Ll][Uu]
dec_literal            {dec_digit}+{int_suffix}?
hex_literal            0[xX]{hex_digit}+{int_suffix}?
integer_literal        {dec_literal}|{hex_literal}
 
real_suffix            [FfDdMm]
sign                   [+\-]
exponent_part          [eE]{sign}?{dec_digit}+
whole_real1            {dec_digit}+{exponent_part}{real_suffix}?
whole_real2            {dec_digit}+{real_suffix}
part_real              {dec_digit}*\.{dec_digit}+{exponent_part}?{real_suffix}?
real_literal           {whole_real1}|{whole_real2}|{part_real}
 
single_char            [^\\\']
simple_esc_seq         \\[\'\"\\0abfnrtv]
uni_esc_seq1           \\u{hex_digit}{4}
uni_esc_seq2           \\U{hex_digit}{8}
uni_esc_seq            {uni_esc_seq1}|{uni_esc_seq2}
hex_esc_seq            \\x{hex_digit}{1,4}
character              {single_char}|{simple_esc_seq}|{hex_esc_seq}|{uni_esc_seq}
character_literal      \'{character}\'
 
 
single_string_char     [^\\\"]
reg_string_char        {single_string_char}|{simple_esc_seq}|{hex_esc_seq}|{uni_esc_seq}
regular_string         \"{reg_string_char}*\"
single_verbatim_char   [^\"]
quote_esc_seq          \"\"
verb_string_char       {single_verbatim_char}|{quote_esc_seq}
verbatim_string        @\"{verb_string_char}*\"
string_literal         {regular_string}|{verbatim_string}
 
 
letter_char            [A-Za-z]
ident_char             {dec_digit}|{letter_char}|"_"|"@"
identifier             ({letter_char}|"_"){ident_char}*
at_identifier          \@{identifier}
 
 
rank_specifier         "["{white_space}*(","{white_space}*)*"]"
 
 
%x IN_COMMENT
 
%s IN_ATTRIB IN_ACCESSOR IN_GETSET
 
%%
 
{preprocessor}        { ; /* ignore */ }
{white_space}         { ; /* ignore */ }
 
                      /***** Comments *****/
"/*"                  { yy_push_state(IN_COMMENT); }
<IN_COMMENT>.         { ; /* ignore */ }
<IN_COMMENT>\n        { ; /* ignore */ }
<IN_COMMENT>"*/"      { yy_pop_state(); }
 
{single_line_comment} { ; /* ignore */ }
 
                      /***** Literals *****/
{integer_literal}     { return INTEGER_LITERAL; }
{real_literal}        { return REAL_LITERAL; }
{character_literal}   { return CHARACTER_LITERAL; }
{string_literal}      { return STRING_LITERAL; }
 
                      /*** Punctuation and Single-Character Operators ***/
","   { return COMMA; }
"["   { return LEFT_BRACKET; }
"]"   { return RIGHT_BRACKET; }
 
{rank_specifier}     { return RANK_SPECIFIER; }
 
                      /*** Multi-Character Operators ***/
"+="  { return PLUSEQ; }
"-="  { return MINUSEQ; }
"*="  { return STAREQ; }
"/="  { return DIVEQ; }
"%="  { return MODEQ; }
"^="  { return XOREQ; }
"&="  { return ANDEQ; }
"|="  { return OREQ; }
"<<"  { return LTLT; }
">>"  { return GTGT; }
">>="  { return GTGTEQ; }
"<<="  { return LTLTEQ; }
"=="  { return EQEQ; }
"!="  { return NOTEQ; }
"<="  { return LEQ; }
">="  { return GEQ; }
"&&"  { return ANDAND; }
"||"  { return OROR; }
"++"  { return PLUSPLUS; }
"--"  { return MINUSMINUS; }
"->"  { return ARROW; }
 
 
                      /*** Those context-sensitive "keywords" ***/
 
<IN_ATTRIB>"assembly"    { return ASSEMBLY; }
<IN_ATTRIB>"field"       { return FIELD; }
<IN_ATTRIB>"method"      { return METHOD; }
<IN_ATTRIB>"module"      { return MODULE; }
<IN_ATTRIB>"param"       { return PARAM; }
<IN_ATTRIB>"property"    { return PROPERTY; }
<IN_ATTRIB>"type"        { return TYPE; }
 
<IN_ACCESSOR>"add"       { return ADD; }
<IN_ACCESSOR>"remove"    { return REMOVE; }
 
<IN_GETSET>"get"         { return GET; }
<IN_GETSET>"set"         { return SET; }
 
{identifier}          { return token_for(yytext); }
{at_identifier}       { return IDENTIFIER; }
 
 
.     { 
        if (is_allowed_char(yytext[0])) return yytext[0];
        else lexical_error("invalid token"); 
      }
%%
 
 
static struct name_value {
  char *name;
  int value;
} name_value;
static struct name_value keywords [] = { 
 /* This list must remain sorted!!! */
    {"abstract", ABSTRACT},
    {"as", AS},
    {"base", BASE},
    {"bool", BOOL},
    {"break", BREAK},
    {"byte", BYTE},
    {"case", CASE},
    {"catch", CATCH},
    {"char", CHAR},
    {"checked", CHECKED},
    {"class", CLASS},
    {"const", CONST},
    {"continue", CONTINUE},
    {"decimal", DECIMAL},
    {"default", DEFAULT},
    {"delegate", DELEGATE},
    {"do", DO},
    {"double", DOUBLE},
    {"else", ELSE},
    {"enum", ENUM},
    {"event", EVENT},
    {"explicit", EXPLICIT},
    {"extern", EXTERN},
    {"false", FALSE},
    {"finally", FINALLY},
    {"fixed", FIXED},
    {"float", FLOAT},
    {"for", FOR},
    {"foreach", FOREACH},
    {"goto", GOTO},
    {"if", IF},
    {"implicit", IMPLICIT},
    {"in", IN},
    {"int", INT},
    {"interface", INTERFACE},
    {"internal", INTERNAL},
    {"is", IS},
    {"lock", LOCK},
    {"long", LONG},
    {"namespace", NAMESPACE},
    {"new", NEW},
    {"null", NULL_LITERAL},
    {"object", OBJECT},
    {"operator", OPERATOR},
    {"out", OUT},
    {"override", OVERRIDE},
    {"params", PARAMS},
    {"private", PRIVATE},
    {"protected", PROTECTED},
    {"public", PUBLIC},
    {"readonly", READONLY},
    {"ref", REF},
    {"return", RETURN},
    {"sbyte", SBYTE},
    {"sealed", SEALED},
    {"short", SHORT},
    {"sizeof", SIZEOF},
    {"stackalloc", STACKALLOC},
    {"static", STATIC},
    {"string", STRING},
    {"struct", STRUCT},
    {"switch", SWITCH},
    {"this", THIS},
    {"throw", THROW},
    {"true", TRUE},
    {"try", TRY},
    {"typeof", TYPEOF},
    {"uint", UINT},
    {"ulong", ULONG},
    {"unchecked", UNCHECKED},
    {"unsafe", UNSAFE},
    {"ushort", USHORT},
    {"using", USING},
    {"virtual", VIRTUAL},
    {"void", VOID},
    {"volatile", VOLATILE},
    {"while", WHILE},
  };    
 
 
/* Conduct a binary search for lexeme in the keywords array
 * between indices start (inclusive) and finish (exclusive)
 */
static int bin_search(const char *lexeme, int start, int finish)
{
  if (start >= finish)  /* Not found */
      return IDENTIFIER;
  else {
    int mid = (start+finish)/2;
    int cmp = strcmp(lexeme,keywords[mid].name);
    if (cmp == 0) 
      return keywords[mid].value;
    else if (cmp < 0)
      return bin_search(lexeme,start,mid);
    else
      return bin_search(lexeme,mid+1,finish);
  }
}
 
static int token_for(const char *lexeme)
{
 
  static int num_keywords = sizeof(keywords) / sizeof(name_value);
  int token = bin_search(lexeme,0,num_keywords);
  if (token == -1)
    token = IDENTIFIER;
  return token;
}
 
static int is_allowed_char(const char c)
{
  static char allowed [] = {
    '.', ';', ':',
    '(', ')', '{', '}', '<', '>',
    '+', '-', '*', '/', '%', '&', '|', '!', '~', '^',
    '=', '?',
  };
  static int num_allowed = sizeof(allowed) / sizeof(char);
  int i;
  for (i=0; i<num_allowed; i++) {
    if (allowed[i]==c) 
      return 1;
  }
  return 0;
}
 
void lexical_error(const char *msg)
{
  fprintf(stderr,"%d:lexical error (%s) [%s]\n",yylineno,msg,yytext);
}
 
 
/*** Switch on/off context-sensitive "keywords" ***/
/* I don't like it any more than you do.  */
 
void lex_enter_attrib(void)
{
  yy_push_state(IN_ATTRIB);
}
void lex_exit_attrib(void)
{
  yy_pop_state();
}
void lex_enter_accessor(void)
{
  yy_push_state(IN_ACCESSOR);
}
void lex_exit_accessor(void)
{
  yy_pop_state();
}
void lex_enter_getset(void)
{
  yy_push_state(IN_GETSET);
}
void lex_exit_getset(void)
{
  yy_pop_state();
}

Merci de t'intéresser à mon problème,
Nicolas.

Bonjour,

J'ai finalement modifié le fichier lexer, et ça fonctionne bien.
Merci quand même de votre aide !

Cordialement,
Nicolas.