]>
Commit | Line | Data |
---|---|---|
1 | /* Bison Grammar Parser -*- C -*- | |
2 | Copyright (C) 2002 Free Software Foundation, Inc. | |
3 | ||
4 | This file is part of Bison, the GNU Compiler Compiler. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2 of the License, or | |
9 | (at your option) any later version. | |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with this program; if not, write to the Free Software | |
18 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |
19 | 02111-1307 USA | |
20 | */ | |
21 | ||
22 | ||
23 | %debug | |
24 | %defines | |
25 | %locations | |
26 | %pure-parser | |
27 | // %error-verbose | |
28 | %defines | |
29 | %name-prefix="gram_" | |
30 | ||
31 | %{ | |
32 | #include "system.h" | |
33 | #include "complain.h" | |
34 | #include "muscle_tab.h" | |
35 | #include "files.h" | |
36 | #include "getargs.h" | |
37 | #include "output.h" | |
38 | #include "symlist.h" | |
39 | #include "gram.h" | |
40 | #include "reader.h" | |
41 | #include "conflicts.h" | |
42 | ||
43 | /* Produce verbose parse errors. */ | |
44 | #define YYERROR_VERBOSE 1 | |
45 | #define YYLLOC_DEFAULT(Current, Rhs, N) \ | |
46 | do { \ | |
47 | if (N) \ | |
48 | { \ | |
49 | Current.first_column = Rhs[1].first_column; \ | |
50 | Current.first_line = Rhs[1].first_line; \ | |
51 | Current.last_column = Rhs[N].last_column; \ | |
52 | Current.last_line = Rhs[N].last_line; \ | |
53 | } \ | |
54 | else \ | |
55 | { \ | |
56 | Current = Rhs[0]; \ | |
57 | } \ | |
58 | } while (0) | |
59 | ||
60 | /* Pass the control structure to YYPARSE and YYLEX. */ | |
61 | #define YYPARSE_PARAM gram_control | |
62 | #define YYLEX_PARAM gram_control | |
63 | /* YYPARSE receives GRAM_CONTROL as a void *. Provide a | |
64 | correctly typed access to it. */ | |
65 | #define yycontrol ((gram_control_t *) gram_control) | |
66 | ||
67 | /* Request detailed parse error messages, and pass them to GRAM_ERROR. | |
68 | FIXME: depends on the undocumented availability of YYLLOC.t */ | |
69 | #undef yyerror | |
70 | #define yyerror(Msg) \ | |
71 | gram_error (&yylloc, Msg) | |
72 | ||
73 | #define YYPRINT(File, Type, Value) \ | |
74 | yyprint (File, Type, &Value) | |
75 | static void yyprint (FILE *file, int type, const yystype *value); | |
76 | ||
77 | symbol_class current_class = unknown_sym; | |
78 | char *current_type = 0; | |
79 | symbol_t *current_lhs; | |
80 | location_t current_lhs_location; | |
81 | assoc_t current_assoc; | |
82 | int current_prec = 0; | |
83 | braced_code_t current_braced_code = action_braced_code; | |
84 | %} | |
85 | ||
86 | ||
87 | /* Only NUMBERS have a value. */ | |
88 | %union | |
89 | { | |
90 | symbol_t *symbol; | |
91 | symbol_list_t *list; | |
92 | int integer; | |
93 | char *string; | |
94 | assoc_t assoc; | |
95 | }; | |
96 | ||
97 | /* Define the tokens together with their human representation. */ | |
98 | %token GRAM_EOF 0 "end of file" | |
99 | %token STRING "string" | |
100 | %token CHARACTER "character" | |
101 | %token INT "integer" | |
102 | ||
103 | %token PERCENT_TOKEN "%token" | |
104 | %token PERCENT_NTERM "%nterm" | |
105 | ||
106 | %token PERCENT_TYPE "%type" | |
107 | %token PERCENT_DESTRUCTOR "%destructor" | |
108 | %token PERCENT_PRINTER "%printer" | |
109 | ||
110 | %token PERCENT_UNION "%union" | |
111 | ||
112 | %token PERCENT_LEFT "%left" | |
113 | %token PERCENT_RIGHT "%right" | |
114 | %token PERCENT_NONASSOC "%nonassoc" | |
115 | ||
116 | %token PERCENT_PREC "%prec" | |
117 | %token PERCENT_DPREC "%dprec" | |
118 | %token PERCENT_MERGE "%merge" | |
119 | ||
120 | ||
121 | /*----------------------. | |
122 | | Global Declarations. | | |
123 | `----------------------*/ | |
124 | ||
125 | %token | |
126 | PERCENT_DEBUG "%debug" | |
127 | PERCENT_DEFINE "%define" | |
128 | PERCENT_DEFINES "%defines" | |
129 | PERCENT_ERROR_VERBOSE "%error-verbose" | |
130 | PERCENT_EXPECT "%expect" | |
131 | PERCENT_FILE_PREFIX "%file-prefix" | |
132 | PERCENT_GLR_PARSER "%glr-parser" | |
133 | PERCENT_LEX_PARAM "%lex-param" | |
134 | PERCENT_LOCATIONS "%locations" | |
135 | PERCENT_NAME_PREFIX "%name-prefix" | |
136 | PERCENT_NO_LINES "%no-lines" | |
137 | PERCENT_OUTPUT "%output" | |
138 | PERCENT_PARSE_PARAM "%parse-param" | |
139 | PERCENT_PURE_PARSER "%pure-parser" | |
140 | PERCENT_SKELETON "%skeleton" | |
141 | PERCENT_START "%start" | |
142 | PERCENT_TOKEN_TABLE "%token-table" | |
143 | PERCENT_VERBOSE "%verbose" | |
144 | PERCENT_YACC "%yacc" | |
145 | ; | |
146 | ||
147 | %token TYPE "type" | |
148 | %token EQUAL "=" | |
149 | %token SEMICOLON ";" | |
150 | %token COLON ":" | |
151 | %token COMMA "," | |
152 | %token PIPE "|" | |
153 | %token ID "identifier" | |
154 | %token PERCENT_PERCENT "%%" | |
155 | %token PROLOGUE "%{...%}" | |
156 | %token EPILOGUE "epilogue" | |
157 | %token BRACED_CODE "{...}" | |
158 | ||
159 | ||
160 | %type <string> CHARACTER TYPE STRING string_content | |
161 | BRACED_CODE PROLOGUE EPILOGUE epilogue.opt action | |
162 | %type <integer> INT | |
163 | %type <symbol> ID symbol string_as_id | |
164 | %type <assoc> precedence_declarator | |
165 | %type <list> symbols.1 | |
166 | %% | |
167 | ||
168 | input: | |
169 | declarations "%%" grammar epilogue.opt | |
170 | { | |
171 | yycontrol->errcode = 0; | |
172 | epilogue_set ($4, @4); | |
173 | } | |
174 | ; | |
175 | ||
176 | ||
177 | /*------------------------------------. | |
178 | | Declarations: before the first %%. | | |
179 | `------------------------------------*/ | |
180 | ||
181 | declarations: | |
182 | /* Nothing */ | |
183 | | declarations declaration semi_colon.opt | |
184 | ; | |
185 | ||
186 | declaration: | |
187 | grammar_declaration | |
188 | | PROLOGUE { prologue_augment ($1, @1); } | |
189 | | "%debug" { debug_flag = 1; } | |
190 | | "%define" string_content string_content { muscle_insert ($2, $3); } | |
191 | | "%defines" { defines_flag = 1; } | |
192 | | "%error-verbose" { error_verbose = 1; } | |
193 | | "%expect" INT { expected_conflicts = $2; } | |
194 | | "%file-prefix" "=" string_content { spec_file_prefix = $3; } | |
195 | | "%glr-parser" { glr_parser = 1; } | |
196 | | "%lex-param" string_content "," string_content | |
197 | { muscle_pair_list_grow ("lex_param", $2, $4); } | |
198 | | "%locations" { locations_flag = 1; } | |
199 | | "%name-prefix" "=" string_content { spec_name_prefix = $3; } | |
200 | | "%no-lines" { no_lines_flag = 1; } | |
201 | | "%output" "=" string_content { spec_outfile = $3; } | |
202 | | "%parse-param" string_content "," string_content | |
203 | { muscle_pair_list_grow ("parse_param", $2, $4); } | |
204 | | "%pure-parser" { pure_parser = 1; } | |
205 | | "%skeleton" string_content { skeleton = $2; } | |
206 | | "%token-table" { token_table_flag = 1; } | |
207 | | "%verbose" { report_flag = 1; } | |
208 | | "%yacc" { yacc_flag = 1; } | |
209 | ; | |
210 | ||
211 | grammar_declaration: | |
212 | precedence_declaration | |
213 | | symbol_declaration | |
214 | | "%start" symbol | |
215 | { | |
216 | grammar_start_symbol_set ($2, @2); | |
217 | } | |
218 | | "%union" BRACED_CODE | |
219 | { | |
220 | typed = 1; | |
221 | MUSCLE_INSERT_INT ("stype_line", @2.first_line); | |
222 | muscle_insert ("stype", $2); | |
223 | } | |
224 | | "%destructor" | |
225 | { current_braced_code = destructor_braced_code; } | |
226 | BRACED_CODE symbols.1 | |
227 | { | |
228 | symbol_list_t *list; | |
229 | for (list = $4; list; list = list->next) | |
230 | symbol_destructor_set (list->sym, $3, @3); | |
231 | symbol_list_free ($4); | |
232 | current_braced_code = action_braced_code; | |
233 | } | |
234 | | "%printer" | |
235 | { current_braced_code = printer_braced_code; } | |
236 | BRACED_CODE symbols.1 | |
237 | { | |
238 | symbol_list_t *list; | |
239 | for (list = $4; list; list = list->next) | |
240 | symbol_printer_set (list->sym, $3, list->location); | |
241 | symbol_list_free ($4); | |
242 | current_braced_code = action_braced_code; | |
243 | } | |
244 | ; | |
245 | ||
246 | symbol_declaration: | |
247 | "%nterm" { current_class = nterm_sym; } symbol_defs.1 | |
248 | { | |
249 | current_class = unknown_sym; | |
250 | current_type = NULL; | |
251 | } | |
252 | | "%token" { current_class = token_sym; } symbol_defs.1 | |
253 | { | |
254 | current_class = unknown_sym; | |
255 | current_type = NULL; | |
256 | } | |
257 | | "%type" TYPE symbols.1 | |
258 | { | |
259 | symbol_list_t *list; | |
260 | for (list = $3; list; list = list->next) | |
261 | symbol_type_set (list->sym, $2, @2); | |
262 | symbol_list_free ($3); | |
263 | } | |
264 | ; | |
265 | ||
266 | precedence_declaration: | |
267 | precedence_declarator type.opt symbols.1 | |
268 | { | |
269 | symbol_list_t *list; | |
270 | ++current_prec; | |
271 | for (list = $3; list; list = list->next) | |
272 | { | |
273 | symbol_type_set (list->sym, current_type, @2); | |
274 | symbol_precedence_set (list->sym, current_prec, $1, @1); | |
275 | } | |
276 | symbol_list_free ($3); | |
277 | current_type = NULL; | |
278 | } | |
279 | ; | |
280 | ||
281 | precedence_declarator: | |
282 | "%left" { $$ = left_assoc; } | |
283 | | "%right" { $$ = right_assoc; } | |
284 | | "%nonassoc" { $$ = non_assoc; } | |
285 | ; | |
286 | ||
287 | type.opt: | |
288 | /* Nothing. */ { current_type = NULL;} | |
289 | | TYPE { current_type = $1; } | |
290 | ; | |
291 | ||
292 | /* One or more nonterminals to be %typed. */ | |
293 | ||
294 | symbols.1: | |
295 | symbol { $$ = symbol_list_new ($1, @1); } | |
296 | | symbols.1 symbol { $$ = symbol_list_prepend ($1, $2, @2); } | |
297 | ; | |
298 | ||
299 | /* One token definition. */ | |
300 | symbol_def: | |
301 | TYPE | |
302 | { | |
303 | current_type = $1; | |
304 | } | |
305 | | ID | |
306 | { | |
307 | symbol_class_set ($1, current_class, @1); | |
308 | symbol_type_set ($1, current_type, @1); | |
309 | } | |
310 | | ID INT | |
311 | { | |
312 | symbol_class_set ($1, current_class, @1); | |
313 | symbol_type_set ($1, current_type, @1); | |
314 | symbol_user_token_number_set ($1, $2, @2); | |
315 | } | |
316 | | ID string_as_id | |
317 | { | |
318 | symbol_class_set ($1, current_class, @1); | |
319 | symbol_type_set ($1, current_type, @1); | |
320 | symbol_make_alias ($1, $2, @$); | |
321 | } | |
322 | | ID INT string_as_id | |
323 | { | |
324 | symbol_class_set ($1, current_class, @1); | |
325 | symbol_type_set ($1, current_type, @1); | |
326 | symbol_user_token_number_set ($1, $2, @2); | |
327 | symbol_make_alias ($1, $3, @$); | |
328 | } | |
329 | ; | |
330 | ||
331 | /* One or more symbol definitions. */ | |
332 | symbol_defs.1: | |
333 | symbol_def | |
334 | {;} | |
335 | | symbol_defs.1 symbol_def | |
336 | {;} | |
337 | ; | |
338 | ||
339 | ||
340 | /*------------------------------------------. | |
341 | | The grammar section: between the two %%. | | |
342 | `------------------------------------------*/ | |
343 | ||
344 | grammar: | |
345 | rules_or_grammar_declaration | |
346 | | grammar rules_or_grammar_declaration | |
347 | ; | |
348 | ||
349 | /* As a Bison extension, one can use the grammar declarations in the | |
350 | body of the grammar. But to remain LALR(1), they must be ended | |
351 | with a semi-colon. */ | |
352 | rules_or_grammar_declaration: | |
353 | rules | |
354 | | grammar_declaration ";" | |
355 | { | |
356 | if (yacc_flag) | |
357 | complain_at (@$, _("POSIX forbids declarations in the grammar")); | |
358 | } | |
359 | | error ";" | |
360 | { | |
361 | yyerrok; | |
362 | } | |
363 | ; | |
364 | ||
365 | rules: | |
366 | ID ":" { current_lhs = $1; current_lhs_location = @1; } rhses.1 ";" | |
367 | {;} | |
368 | ; | |
369 | ||
370 | rhses.1: | |
371 | rhs { grammar_rule_end (@1); } | |
372 | | rhses.1 "|" rhs { grammar_rule_end (@3); } | |
373 | ; | |
374 | ||
375 | rhs: | |
376 | /* Nothing. */ | |
377 | { grammar_rule_begin (current_lhs, current_lhs_location); } | |
378 | | rhs symbol | |
379 | { grammar_current_rule_symbol_append ($2, @2); } | |
380 | | rhs action | |
381 | { grammar_current_rule_action_append ($2, @2); } | |
382 | | rhs "%prec" symbol | |
383 | { grammar_current_rule_prec_set ($3, @3); } | |
384 | | rhs "%dprec" INT | |
385 | { grammar_current_rule_dprec_set ($3, @3); } | |
386 | | rhs "%merge" TYPE | |
387 | { grammar_current_rule_merge_set ($3, @3); } | |
388 | ; | |
389 | ||
390 | symbol: | |
391 | ID { $$ = $1; } | |
392 | | string_as_id { $$ = $1; } | |
393 | | CHARACTER { $$ = symbol_get ($1, @1); } | |
394 | ; | |
395 | ||
396 | action: | |
397 | BRACED_CODE | |
398 | { $$ = $1; } | |
399 | ; | |
400 | ||
401 | /* A string used as an ID: we have to keep the quotes. */ | |
402 | string_as_id: | |
403 | STRING | |
404 | { | |
405 | $$ = symbol_get ($1, @1); | |
406 | symbol_class_set ($$, token_sym, @1); | |
407 | } | |
408 | ; | |
409 | ||
410 | /* A string used for its contents. Strip the quotes. */ | |
411 | string_content: | |
412 | STRING | |
413 | { | |
414 | $$ = $1 + 1; | |
415 | $$[strlen ($$) - 1] = '\0'; | |
416 | }; | |
417 | ||
418 | ||
419 | epilogue.opt: | |
420 | /* Nothing. */ | |
421 | { | |
422 | $$ = xstrdup (""); | |
423 | } | |
424 | | "%%" EPILOGUE | |
425 | { | |
426 | $$ = $2; | |
427 | } | |
428 | ; | |
429 | ||
430 | semi_colon.opt: | |
431 | /* Nothing. */ | |
432 | | ";" | |
433 | ; | |
434 | %% | |
435 | /*------------------------------------------------------------------. | |
436 | | When debugging the parser, display tokens' locations and values. | | |
437 | `------------------------------------------------------------------*/ | |
438 | ||
439 | static void | |
440 | yyprint (FILE *file, | |
441 | int type, const yystype *value) | |
442 | { | |
443 | fputc (' ', file); | |
444 | switch (type) | |
445 | { | |
446 | case CHARACTER: | |
447 | fprintf (file, " = '%s'", value->string); | |
448 | break; | |
449 | ||
450 | case ID: | |
451 | fprintf (file, " = %s", value->symbol->tag); | |
452 | break; | |
453 | ||
454 | case INT: | |
455 | fprintf (file, " = %d", value->integer); | |
456 | break; | |
457 | ||
458 | case STRING: | |
459 | fprintf (file, " = \"%s\"", value->string); | |
460 | break; | |
461 | ||
462 | case TYPE: | |
463 | fprintf (file, " = <%s>", value->string); | |
464 | break; | |
465 | ||
466 | case BRACED_CODE: | |
467 | case PROLOGUE: | |
468 | case EPILOGUE: | |
469 | fprintf (file, " = {{ %s }}", value->string); | |
470 | break; | |
471 | } | |
472 | } | |
473 | ||
474 | void | |
475 | gram_error (location_t *yylloc, const char *msg) | |
476 | { | |
477 | complain_at (*yylloc, "%s", msg); | |
478 | } |