OLD | NEW |
(Empty) | |
| 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, grammar_prio, &@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, grammar_prio, &@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 } |
OLD | NEW |