a1740e74ad26d5eac427d5b040c19f94b96f3161
[bison.git] / src / parse-gram.y
1 %{/* Bison Grammar Parser -*- C -*-
2
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software
4 Foundation, Inc.
5
6 This file is part of Bison, the GNU Compiler Compiler.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 #include <config.h>
22 #include "system.h"
23
24 #include "complain.h"
25 #include "conflicts.h"
26 #include "files.h"
27 #include "getargs.h"
28 #include "gram.h"
29 #include "muscle_tab.h"
30 #include "quotearg.h"
31 #include "reader.h"
32 #include "symlist.h"
33 #include "scan-gram.h"
34 #include "scan-code.h"
35
36 #define YYLLOC_DEFAULT(Current, Rhs, N) (Current) = lloc_default (Rhs, N)
37 static YYLTYPE lloc_default (YYLTYPE const *, int);
38
39 #define YY_LOCATION_PRINT(File, Loc) \
40 location_print (File, Loc)
41
42 static void version_check (location const *loc, char const *version);
43
44 /* Request detailed syntax error messages, and pass them to GRAM_ERROR.
45 FIXME: depends on the undocumented availability of YYLLOC. */
46 #undef yyerror
47 #define yyerror(Msg) \
48 gram_error (&yylloc, Msg)
49 static void gram_error (location const *, char const *);
50
51 static char const *char_name (char);
52
53 /** Add a lex-param or a parse-param.
54 *
55 * \param type \a lex_param or \a parse_param
56 * \param decl the formal argument
57 * \param loc the location in the source.
58 */
59 static void add_param (char const *type, char *decl, location loc);
60
61
62 static symbol_class current_class = unknown_sym;
63 static uniqstr current_type = NULL;
64 static symbol *current_lhs;
65 static location current_lhs_location;
66 static int current_prec = 0;
67
68 #define YYTYPE_INT16 int_fast16_t
69 #define YYTYPE_INT8 int_fast8_t
70 #define YYTYPE_UINT16 uint_fast16_t
71 #define YYTYPE_UINT8 uint_fast8_t
72 %}
73
74 %debug
75 %verbose
76 %defines
77 %locations
78 %pure-parser
79 %error-verbose
80 %name-prefix="gram_"
81 %expect 0
82
83 %initial-action
84 {
85 /* Bison's grammar can initial empty locations, hence a default
86 location is needed. */
87 boundary_set (&@$.start, current_file, 1, 1);
88 boundary_set (&@$.end, current_file, 1, 1);
89 }
90
91 %union
92 {
93 symbol *symbol;
94 symbol_list *list;
95 int integer;
96 char const *chars;
97 char *code;
98 assoc assoc;
99 uniqstr uniqstr;
100 unsigned char character;
101 };
102
103 /* Define the tokens together with their human representation. */
104 %token GRAM_EOF 0 "end of file"
105 %token STRING "string"
106 %token INT "integer"
107
108 %token PERCENT_TOKEN "%token"
109 %token PERCENT_NTERM "%nterm"
110
111 %token PERCENT_TYPE "%type"
112 %token PERCENT_DESTRUCTOR "%destructor"
113 %token PERCENT_PRINTER "%printer"
114
115 %token PERCENT_LEFT "%left"
116 %token PERCENT_RIGHT "%right"
117 %token PERCENT_NONASSOC "%nonassoc"
118
119 %token PERCENT_PREC "%prec"
120 %token PERCENT_DPREC "%dprec"
121 %token PERCENT_MERGE "%merge"
122
123
124 /*----------------------.
125 | Global Declarations. |
126 `----------------------*/
127
128 %token
129 PERCENT_CODE "%code"
130 PERCENT_DEBUG "%debug"
131 PERCENT_DEFAULT_PREC "%default-prec"
132 PERCENT_DEFINE "%define"
133 PERCENT_DEFINES "%defines"
134 PERCENT_ERROR_VERBOSE "%error-verbose"
135 PERCENT_EXPECT "%expect"
136 PERCENT_EXPECT_RR "%expect-rr"
137 PERCENT_FILE_PREFIX "%file-prefix"
138 PERCENT_GLR_PARSER "%glr-parser"
139 PERCENT_INITIAL_ACTION "%initial-action"
140 PERCENT_LANGUAGE "%language"
141 PERCENT_LEX_PARAM "%lex-param"
142 PERCENT_LOCATIONS "%locations"
143 PERCENT_NAME_PREFIX "%name-prefix"
144 PERCENT_NO_DEFAULT_PREC "%no-default-prec"
145 PERCENT_NO_LINES "%no-lines"
146 PERCENT_NONDETERMINISTIC_PARSER
147 "%nondeterministic-parser"
148 PERCENT_OUTPUT "%output"
149 PERCENT_PARSE_PARAM "%parse-param"
150 PERCENT_PURE_PARSER "%pure-parser"
151 PERCENT_REQUIRE "%require"
152 PERCENT_SKELETON "%skeleton"
153 PERCENT_START "%start"
154 PERCENT_TOKEN_TABLE "%token-table"
155 PERCENT_VERBOSE "%verbose"
156 PERCENT_YACC "%yacc"
157 ;
158
159 %token BRACED_CODE "{...}"
160 %token CHAR "char"
161 %token EPILOGUE "epilogue"
162 %token EQUAL "="
163 %token ID "identifier"
164 %token ID_COLON "identifier:"
165 %token PERCENT_PERCENT "%%"
166 %token PIPE "|"
167 %token PROLOGUE "%{...%}"
168 %token SEMICOLON ";"
169 %token TYPE "type"
170 %token TYPE_TAG_ANY "<*>"
171 %token TYPE_TAG_NONE "<>"
172
173 %type <character> CHAR
174 %printer { fputs (char_name ($$), stderr); } CHAR
175
176 /* braceless is not to be used for rule or symbol actions, as it
177 calls code_props_plain_init. */
178 %type <chars> STRING "%{...%}" EPILOGUE braceless content.opt
179 %type <code> "{...}"
180 %printer { fputs (quotearg_style (c_quoting_style, $$), stderr); }
181 STRING
182 %printer { fprintf (stderr, "{\n%s\n}", $$); }
183 braceless content.opt "{...}" "%{...%}" EPILOGUE
184
185 %type <uniqstr> TYPE ID ID_COLON variable
186 %printer { fprintf (stderr, "<%s>", $$); } TYPE
187 %printer { fputs ($$, stderr); } ID variable
188 %printer { fprintf (stderr, "%s:", $$); } ID_COLON
189
190 %type <integer> INT
191 %printer { fprintf (stderr, "%d", $$); } INT
192
193 %type <symbol> id id_colon symbol symbol.prec string_as_id
194 %printer { fprintf (stderr, "%s", $$->tag); } id symbol string_as_id
195 %printer { fprintf (stderr, "%s:", $$->tag); } id_colon
196
197 %type <assoc> precedence_declarator
198 %type <list> symbols.1 symbols.prec generic_symlist generic_symlist_item
199 %%
200
201 input:
202 prologue_declarations "%%" grammar epilogue.opt
203 ;
204
205
206 /*------------------------------------.
207 | Declarations: before the first %%. |
208 `------------------------------------*/
209
210 prologue_declarations:
211 /* Nothing */
212 | prologue_declarations prologue_declaration
213 ;
214
215 prologue_declaration:
216 grammar_declaration
217 | "%{...%}"
218 {
219 code_props plain_code;
220 code_props_plain_init (&plain_code, $1, @1);
221 code_props_translate_code (&plain_code);
222 gram_scanner_last_string_free ();
223 muscle_code_grow (union_seen ? "post_prologue" : "pre_prologue",
224 plain_code.code, @1);
225 code_scanner_last_string_free ();
226 }
227 | "%debug" { debug_flag = true; }
228 | "%define" variable content.opt
229 {
230 muscle_percent_define_insert ($2, @2, $3);
231 }
232 | "%defines" { defines_flag = true; }
233 | "%defines" STRING
234 {
235 defines_flag = true;
236 spec_defines_file = xstrdup ($2);
237 }
238 | "%error-verbose" { error_verbose = true; }
239 | "%expect" INT { expected_sr_conflicts = $2; }
240 | "%expect-rr" INT { expected_rr_conflicts = $2; }
241 | "%file-prefix" STRING { spec_file_prefix = $2; }
242 | "%file-prefix" "=" STRING { spec_file_prefix = $3; } /* deprecated */
243 | "%glr-parser"
244 {
245 nondeterministic_parser = true;
246 glr_parser = true;
247 }
248 | "%initial-action" "{...}"
249 {
250 code_props action;
251 code_props_symbol_action_init (&action, $2, @2);
252 code_props_translate_code (&action);
253 gram_scanner_last_string_free ();
254 muscle_code_grow ("initial_action", action.code, @2);
255 code_scanner_last_string_free ();
256 }
257 | "%language" STRING { language_argmatch ($2, 1, @1); }
258 | "%lex-param" "{...}" { add_param ("lex_param", $2, @2); }
259 | "%locations" { locations_flag = true; }
260 | "%name-prefix" STRING { spec_name_prefix = $2; }
261 | "%name-prefix" "=" STRING { spec_name_prefix = $3; } /* deprecated */
262 | "%no-lines" { no_lines_flag = true; }
263 | "%nondeterministic-parser" { nondeterministic_parser = true; }
264 | "%output" STRING { spec_outfile = $2; }
265 | "%output" "=" STRING { spec_outfile = $3; } /* deprecated */
266 | "%parse-param" "{...}" { add_param ("parse_param", $2, @2); }
267 | "%pure-parser"
268 {
269 /* %pure-parser is deprecated in favor of `%define api.pure', so use
270 `%define api.pure' in a backward-compatible manner here. First, don't
271 complain if %pure-parser is specified multiple times. */
272 if (!muscle_find_const ("percent_define(api.pure)"))
273 muscle_percent_define_insert ("api.pure", @1, "");
274 /* In all cases, use api.pure now so that the backend doesn't complain if
275 the skeleton ignores api.pure, but do warn now if there's a previous
276 conflicting definition from an actual %define. */
277 if (!muscle_percent_define_flag_if ("api.pure"))
278 muscle_percent_define_insert ("api.pure", @1, "");
279 }
280 | "%require" STRING { version_check (&@2, $2); }
281 | "%skeleton" STRING
282 {
283 char const *skeleton_user = $2;
284 if (strchr (skeleton_user, '/'))
285 {
286 size_t dir_length = strlen (current_file);
287 char *skeleton_build;
288 while (dir_length && current_file[dir_length - 1] != '/')
289 --dir_length;
290 while (dir_length && current_file[dir_length - 1] == '/')
291 --dir_length;
292 skeleton_build =
293 xmalloc (dir_length + 1 + strlen (skeleton_user) + 1);
294 if (dir_length > 0)
295 {
296 strncpy (skeleton_build, current_file, dir_length);
297 skeleton_build[dir_length++] = '/';
298 }
299 strcpy (skeleton_build + dir_length, skeleton_user);
300 skeleton_user = uniqstr_new (skeleton_build);
301 free (skeleton_build);
302 }
303 skeleton_arg (skeleton_user, 1, @1);
304 }
305 | "%token-table" { token_table_flag = true; }
306 | "%verbose" { report_flag |= report_states; }
307 | "%yacc" { yacc_flag = true; }
308 | /*FIXME: Err? What is this horror doing here? */ ";"
309 ;
310
311 grammar_declaration:
312 precedence_declaration
313 | symbol_declaration
314 | "%start" symbol
315 {
316 grammar_start_symbol_set ($2, @2);
317 }
318 | "%destructor" "{...}" generic_symlist
319 {
320 symbol_list *list;
321 for (list = $3; list; list = list->next)
322 symbol_list_destructor_set (list, $2, @2);
323 symbol_list_free ($3);
324 }
325 | "%printer" "{...}" generic_symlist
326 {
327 symbol_list *list;
328 for (list = $3; list; list = list->next)
329 symbol_list_printer_set (list, $2, @2);
330 symbol_list_free ($3);
331 }
332 | "%default-prec"
333 {
334 default_prec = true;
335 }
336 | "%no-default-prec"
337 {
338 default_prec = false;
339 }
340 | "%code" braceless
341 {
342 /* Do not invoke muscle_percent_code_grow here since it invokes
343 muscle_user_name_list_grow. */
344 muscle_code_grow ("percent_code()", $2, @2);
345 code_scanner_last_string_free ();
346 }
347 | "%code" ID braceless
348 {
349 muscle_percent_code_grow ($2, @2, $3, @3);
350 code_scanner_last_string_free ();
351 }
352 ;
353
354
355 /*---------.
356 | %union. |
357 `---------*/
358
359 %token PERCENT_UNION "%union";
360
361 union_name:
362 /* Nothing. */ {}
363 | ID { muscle_code_grow ("union_name", $1, @1); }
364 ;
365
366 grammar_declaration:
367 "%union" union_name braceless
368 {
369 union_seen = true;
370 muscle_code_grow ("stype", $3, @3);
371 code_scanner_last_string_free ();
372 }
373 ;
374
375
376
377
378 symbol_declaration:
379 "%nterm" { current_class = nterm_sym; } symbol_defs.1
380 {
381 current_class = unknown_sym;
382 current_type = NULL;
383 }
384 | "%token" { current_class = token_sym; } symbol_defs.1
385 {
386 current_class = unknown_sym;
387 current_type = NULL;
388 }
389 | "%type" TYPE symbols.1
390 {
391 symbol_list *list;
392 tag_seen = true;
393 for (list = $3; list; list = list->next)
394 symbol_type_set (list->content.sym, $2, @2);
395 symbol_list_free ($3);
396 }
397 ;
398
399 precedence_declaration:
400 precedence_declarator type.opt symbols.prec
401 {
402 symbol_list *list;
403 ++current_prec;
404 for (list = $3; list; list = list->next)
405 {
406 symbol_type_set (list->content.sym, current_type, @2);
407 symbol_precedence_set (list->content.sym, current_prec, $1, @1);
408 }
409 symbol_list_free ($3);
410 current_type = NULL;
411 }
412 ;
413
414 precedence_declarator:
415 "%left" { $$ = left_assoc; }
416 | "%right" { $$ = right_assoc; }
417 | "%nonassoc" { $$ = non_assoc; }
418 ;
419
420 type.opt:
421 /* Nothing. */ { current_type = NULL; }
422 | TYPE { current_type = $1; tag_seen = true; }
423 ;
424
425 /* Just like symbols.1 but accept INT for the sake of POSIX. */
426 symbols.prec:
427 symbol.prec
428 { $$ = symbol_list_sym_new ($1, @1); }
429 | symbols.prec symbol.prec
430 { $$ = symbol_list_prepend ($1, symbol_list_sym_new ($2, @2)); }
431 ;
432
433 symbol.prec:
434 symbol { $$ = $1; }
435 | symbol INT { $$ = $1; symbol_user_token_number_set ($1, $2, @2); }
436 ;
437
438 /* One or more symbols to be %typed. */
439 symbols.1:
440 symbol
441 { $$ = symbol_list_sym_new ($1, @1); }
442 | symbols.1 symbol
443 { $$ = symbol_list_prepend ($1, symbol_list_sym_new ($2, @2)); }
444 ;
445
446 generic_symlist:
447 generic_symlist_item { $$ = $1; }
448 | generic_symlist generic_symlist_item { $$ = symbol_list_prepend ($1, $2); }
449 ;
450
451 generic_symlist_item:
452 symbol { $$ = symbol_list_sym_new ($1, @1); }
453 | TYPE { $$ = symbol_list_type_new ($1, @1); }
454 | "<*>" { $$ = symbol_list_default_tagged_new (@1); }
455 | "<>" { $$ = symbol_list_default_tagless_new (@1); }
456 ;
457
458 /* One token definition. */
459 symbol_def:
460 TYPE
461 {
462 current_type = $1;
463 tag_seen = true;
464 }
465 | id
466 {
467 symbol_class_set ($1, current_class, @1, true);
468 symbol_type_set ($1, current_type, @1);
469 }
470 | id INT
471 {
472 symbol_class_set ($1, current_class, @1, true);
473 symbol_type_set ($1, current_type, @1);
474 symbol_user_token_number_set ($1, $2, @2);
475 }
476 | id string_as_id
477 {
478 symbol_class_set ($1, current_class, @1, true);
479 symbol_type_set ($1, current_type, @1);
480 symbol_make_alias ($1, $2, @$);
481 }
482 | id INT string_as_id
483 {
484 symbol_class_set ($1, current_class, @1, true);
485 symbol_type_set ($1, current_type, @1);
486 symbol_user_token_number_set ($1, $2, @2);
487 symbol_make_alias ($1, $3, @$);
488 }
489 ;
490
491 /* One or more symbol definitions. */
492 symbol_defs.1:
493 symbol_def
494 | symbol_defs.1 symbol_def
495 ;
496
497
498 /*------------------------------------------.
499 | The grammar section: between the two %%. |
500 `------------------------------------------*/
501
502 grammar:
503 rules_or_grammar_declaration
504 | grammar rules_or_grammar_declaration
505 ;
506
507 /* As a Bison extension, one can use the grammar declarations in the
508 body of the grammar. */
509 rules_or_grammar_declaration:
510 rules
511 | grammar_declaration ";"
512 | error ";"
513 {
514 yyerrok;
515 }
516 ;
517
518 rules:
519 id_colon { current_lhs = $1; current_lhs_location = @1; } rhses.1
520 ;
521
522 rhses.1:
523 rhs { grammar_current_rule_end (@1); }
524 | rhses.1 "|" rhs { grammar_current_rule_end (@3); }
525 | rhses.1 ";"
526 ;
527
528 rhs:
529 /* Nothing. */
530 { grammar_current_rule_begin (current_lhs, current_lhs_location); }
531 | rhs symbol
532 { grammar_current_rule_symbol_append ($2, @2); }
533 | rhs "{...}"
534 { grammar_current_rule_action_append ($2, @2); }
535 | rhs "%prec" symbol
536 { grammar_current_rule_prec_set ($3, @3); }
537 | rhs "%dprec" INT
538 { grammar_current_rule_dprec_set ($3, @3); }
539 | rhs "%merge" TYPE
540 { grammar_current_rule_merge_set ($3, @3); }
541 ;
542
543
544 /*---------------------------.
545 | variable and content.opt. |
546 `---------------------------*/
547
548 variable:
549 ID
550 | STRING { $$ = uniqstr_new ($1); } /* deprecated and not M4-friendly */
551 ;
552
553 /* Some content or empty by default. */
554 content.opt:
555 /* Nothing. */
556 {
557 $$ = "";
558 }
559 | STRING
560 ;
561
562
563 /*------------.
564 | braceless. |
565 `------------*/
566
567 braceless:
568 "{...}"
569 {
570 code_props plain_code;
571 $1[strlen ($1) - 1] = '\n';
572 code_props_plain_init (&plain_code, $1+1, @1);
573 code_props_translate_code (&plain_code);
574 gram_scanner_last_string_free ();
575 $$ = plain_code.code;
576 }
577 ;
578
579
580 /*--------------.
581 | Identifiers. |
582 `--------------*/
583
584 /* Identifiers are returned as uniqstr values by the scanner.
585 Depending on their use, we may need to make them genuine symbols. */
586
587 id:
588 ID
589 { $$ = symbol_from_uniqstr ($1, @1); }
590 | CHAR
591 {
592 $$ = symbol_get (char_name ($1), @1);
593 symbol_class_set ($$, token_sym, @1, false);
594 symbol_user_token_number_set ($$, $1, @1);
595 }
596 ;
597
598 id_colon:
599 ID_COLON { $$ = symbol_from_uniqstr ($1, @1); }
600 ;
601
602
603 symbol:
604 id
605 | string_as_id
606 ;
607
608 /* A string used as an ID: quote it. */
609 string_as_id:
610 STRING
611 {
612 $$ = symbol_get (quotearg_style (c_quoting_style, $1), @1);
613 symbol_class_set ($$, token_sym, @1, false);
614 }
615 ;
616
617 epilogue.opt:
618 /* Nothing. */
619 | "%%" EPILOGUE
620 {
621 code_props plain_code;
622 code_props_plain_init (&plain_code, $2, @2);
623 code_props_translate_code (&plain_code);
624 gram_scanner_last_string_free ();
625 muscle_code_grow ("epilogue", plain_code.code, @2);
626 code_scanner_last_string_free ();
627 }
628 ;
629
630 %%
631
632
633 /* Return the location of the left-hand side of a rule whose
634 right-hand side is RHS[1] ... RHS[N]. Ignore empty nonterminals in
635 the right-hand side, and return an empty location equal to the end
636 boundary of RHS[0] if the right-hand side is empty. */
637
638 static YYLTYPE
639 lloc_default (YYLTYPE const *rhs, int n)
640 {
641 int i;
642 YYLTYPE loc;
643
644 /* SGI MIPSpro 7.4.1m miscompiles "loc.start = loc.end = rhs[n].end;".
645 The bug is fixed in 7.4.2m, but play it safe for now. */
646 loc.start = rhs[n].end;
647 loc.end = rhs[n].end;
648
649 /* Ignore empty nonterminals the start of the the right-hand side.
650 Do not bother to ignore them at the end of the right-hand side,
651 since empty nonterminals have the same end as their predecessors. */
652 for (i = 1; i <= n; i++)
653 if (! equal_boundaries (rhs[i].start, rhs[i].end))
654 {
655 loc.start = rhs[i].start;
656 break;
657 }
658
659 return loc;
660 }
661
662
663 /* Add a lex-param or a parse-param (depending on TYPE) with
664 declaration DECL and location LOC. */
665
666 static void
667 add_param (char const *type, char *decl, location loc)
668 {
669 static char const alphanum[26 + 26 + 1 + 10] =
670 "abcdefghijklmnopqrstuvwxyz"
671 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
672 "_"
673 "0123456789";
674 char const *name_start = NULL;
675 char *p;
676
677 /* Stop on last actual character. */
678 for (p = decl; p[1]; p++)
679 if ((p == decl
680 || ! memchr (alphanum, p[-1], sizeof alphanum))
681 && memchr (alphanum, p[0], sizeof alphanum - 10))
682 name_start = p;
683
684 /* Strip the surrounding '{' and '}', and any blanks just inside
685 the braces. */
686 while (*--p == ' ' || *p == '\t')
687 continue;
688 p[1] = '\0';
689 while (*++decl == ' ' || *decl == '\t')
690 continue;
691
692 if (! name_start)
693 complain_at (loc, _("missing identifier in parameter declaration"));
694 else
695 {
696 char *name;
697 size_t name_len;
698
699 for (name_len = 1;
700 memchr (alphanum, name_start[name_len], sizeof alphanum);
701 name_len++)
702 continue;
703
704 name = xmalloc (name_len + 1);
705 memcpy (name, name_start, name_len);
706 name[name_len] = '\0';
707 muscle_pair_list_grow (type, decl, name);
708 free (name);
709 }
710
711 gram_scanner_last_string_free ();
712 }
713
714
715 static void
716 version_check (location const *loc, char const *version)
717 {
718 if (strverscmp (version, PACKAGE_VERSION) > 0)
719 {
720 complain_at (*loc, "require bison %s, but have %s",
721 version, PACKAGE_VERSION);
722 exit (63);
723 }
724 }
725
726 static void
727 gram_error (location const *loc, char const *msg)
728 {
729 complain_at (*loc, "%s", msg);
730 }
731
732 char const *
733 token_name (int type)
734 {
735 return yytname[YYTRANSLATE (type)];
736 }
737
738 static char const *
739 char_name (char c)
740 {
741 if (c == '\'')
742 return "'\\''";
743 else
744 {
745 char buf[4];
746 buf[0] = '\''; buf[1] = c; buf[2] = '\''; buf[3] = '\0';
747 return quotearg_style (escape_quoting_style, buf);
748 }
749 }