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