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