]>
Commit | Line | Data |
---|---|---|
12ffdd28 | 1 | %{/* Bison Grammar Parser -*- C -*- |
a737b216 | 2 | |
68f91d58 | 3 | Copyright (C) 2002-2013 Free Software Foundation, Inc. |
e9955c83 AD |
4 | |
5 | This file is part of Bison, the GNU Compiler Compiler. | |
6 | ||
f16b0819 | 7 | This program is free software: you can redistribute it and/or modify |
e9955c83 | 8 | it under the terms of the GNU General Public License as published by |
f16b0819 | 9 | the Free Software Foundation, either version 3 of the License, or |
e9955c83 AD |
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 | |
f16b0819 | 18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
e9955c83 | 19 | |
2cec9080 | 20 | #include <config.h> |
e9955c83 | 21 | #include "system.h" |
3d2cbc26 | 22 | |
457bf919 | 23 | #include "c-ctype.h" |
b275314e | 24 | #include "complain.h" |
3d2cbc26 | 25 | #include "conflicts.h" |
e9955c83 AD |
26 | #include "files.h" |
27 | #include "getargs.h" | |
e9955c83 | 28 | #include "gram.h" |
23ec25b7 | 29 | #include "muscle-tab.h" |
d5e8574b | 30 | #include "named-ref.h" |
ca407bdf | 31 | #include "quotearg.h" |
e9955c83 | 32 | #include "reader.h" |
3d2cbc26 | 33 | #include "symlist.h" |
e9071366 AD |
34 | #include "scan-gram.h" |
35 | #include "scan-code.h" | |
e54ec80c | 36 | #include "xmemdup0.h" |
e9955c83 | 37 | |
b7295522 PE |
38 | #define YYLLOC_DEFAULT(Current, Rhs, N) (Current) = lloc_default (Rhs, N) |
39 | static YYLTYPE lloc_default (YYLTYPE const *, int); | |
4cdb01db | 40 | |
b233d555 | 41 | #define YY_LOCATION_PRINT(File, Loc) \ |
f0064700 | 42 | location_print (File, Loc) |
b233d555 | 43 | |
b50d2359 AD |
44 | static void version_check (location const *loc, char const *version); |
45 | ||
6e649e65 | 46 | /* Request detailed syntax error messages, and pass them to GRAM_ERROR. |
ad8a3efc | 47 | FIXME: depends on the undocumented availability of YYLLOC. */ |
e9955c83 AD |
48 | #undef yyerror |
49 | #define yyerror(Msg) \ | |
f0064700 | 50 | gram_error (&yylloc, Msg) |
3d2cbc26 | 51 | static void gram_error (location const *, char const *); |
e9955c83 | 52 | |
33ad1a9c PE |
53 | static char const *char_name (char); |
54 | ||
2ce4ed68 AD |
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 | ||
1773ceee | 63 | |
04098407 | 64 | static symbol_class current_class = unknown_sym; |
ddc8ede1 | 65 | static uniqstr current_type = NULL; |
8f462efe | 66 | static symbol *current_lhs_symbol; |
877519f8 | 67 | static location current_lhs_location; |
7685e2f7 | 68 | static named_ref *current_lhs_named_ref; |
04098407 | 69 | static int current_prec = 0; |
d42cf844 | 70 | |
8f462efe AD |
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 | ||
cb48f191 PE |
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 | |
e9955c83 AD |
94 | %} |
95 | ||
12ffdd28 | 96 | %debug |
e73ac5a0 AD |
97 | %define api.prefix "gram_" |
98 | %define api.pure | |
99 | %define parse.lac full | |
12ffdd28 | 100 | %defines |
12ffdd28 | 101 | %error-verbose |
219741d8 | 102 | %expect 0 |
e73ac5a0 AD |
103 | %locations |
104 | %verbose | |
12ffdd28 | 105 | |
cd3684cf AD |
106 | %initial-action |
107 | { | |
108 | /* Bison's grammar can initial empty locations, hence a default | |
109 | location is needed. */ | |
4a678af8 JD |
110 | boundary_set (&@$.start, current_file, 1, 1); |
111 | boundary_set (&@$.end, current_file, 1, 1); | |
cd3684cf | 112 | } |
e9955c83 | 113 | |
e9955c83 AD |
114 | %union |
115 | { | |
3d2cbc26 PE |
116 | symbol *symbol; |
117 | symbol_list *list; | |
e9955c83 | 118 | int integer; |
eb095650 PE |
119 | char const *chars; |
120 | char *code; | |
3d2cbc26 PE |
121 | assoc assoc; |
122 | uniqstr uniqstr; | |
58d7a1a1 | 123 | unsigned char character; |
7685e2f7 | 124 | named_ref *named_ref; |
e9955c83 AD |
125 | }; |
126 | ||
f9a85a15 | 127 | /* Define the tokens together with their human representation. */ |
3d38c03a AD |
128 | %token GRAM_EOF 0 "end of file" |
129 | %token STRING "string" | |
3d38c03a | 130 | %token INT "integer" |
e9955c83 | 131 | |
9280d3ef AD |
132 | %token PERCENT_TOKEN "%token" |
133 | %token PERCENT_NTERM "%nterm" | |
366eea36 | 134 | |
9280d3ef | 135 | %token PERCENT_TYPE "%type" |
e9071366 AD |
136 | %token PERCENT_DESTRUCTOR "%destructor" |
137 | %token PERCENT_PRINTER "%printer" | |
366eea36 | 138 | |
9280d3ef AD |
139 | %token PERCENT_LEFT "%left" |
140 | %token PERCENT_RIGHT "%right" | |
141 | %token PERCENT_NONASSOC "%nonassoc" | |
04e60654 | 142 | |
3d38c03a AD |
143 | %token PERCENT_PREC "%prec" |
144 | %token PERCENT_DPREC "%dprec" | |
145 | %token PERCENT_MERGE "%merge" | |
e9955c83 | 146 | |
e9955c83 | 147 | |
ae7453f2 AD |
148 | /*----------------------. |
149 | | Global Declarations. | | |
150 | `----------------------*/ | |
151 | ||
152 | %token | |
136a0f76 | 153 | PERCENT_CODE "%code" |
cd3684cf | 154 | PERCENT_DEBUG "%debug" |
39a06c25 | 155 | PERCENT_DEFAULT_PREC "%default-prec" |
cd3684cf AD |
156 | PERCENT_DEFINE "%define" |
157 | PERCENT_DEFINES "%defines" | |
158 | PERCENT_ERROR_VERBOSE "%error-verbose" | |
159 | PERCENT_EXPECT "%expect" | |
d6328241 | 160 | PERCENT_EXPECT_RR "%expect-rr" |
cd3684cf AD |
161 | PERCENT_FILE_PREFIX "%file-prefix" |
162 | PERCENT_GLR_PARSER "%glr-parser" | |
e9071366 | 163 | PERCENT_INITIAL_ACTION "%initial-action" |
0e021770 | 164 | PERCENT_LANGUAGE "%language" |
e9071366 | 165 | PERCENT_LEX_PARAM "%lex-param" |
cd3684cf AD |
166 | PERCENT_LOCATIONS "%locations" |
167 | PERCENT_NAME_PREFIX "%name-prefix" | |
22fccf95 | 168 | PERCENT_NO_DEFAULT_PREC "%no-default-prec" |
cd3684cf AD |
169 | PERCENT_NO_LINES "%no-lines" |
170 | PERCENT_NONDETERMINISTIC_PARSER | |
f0064700 | 171 | "%nondeterministic-parser" |
cd3684cf | 172 | PERCENT_OUTPUT "%output" |
e9071366 | 173 | PERCENT_PARSE_PARAM "%parse-param" |
cd3684cf | 174 | PERCENT_PURE_PARSER "%pure-parser" |
f0064700 | 175 | PERCENT_REQUIRE "%require" |
cd3684cf AD |
176 | PERCENT_SKELETON "%skeleton" |
177 | PERCENT_START "%start" | |
178 | PERCENT_TOKEN_TABLE "%token-table" | |
179 | PERCENT_VERBOSE "%verbose" | |
180 | PERCENT_YACC "%yacc" | |
ae7453f2 | 181 | ; |
e9955c83 | 182 | |
58d7a1a1 | 183 | %token BRACED_CODE "{...}" |
42ec0ae1 | 184 | %token BRACKETED_ID "[identifier]" |
58d7a1a1 AD |
185 | %token CHAR "char" |
186 | %token EPILOGUE "epilogue" | |
3d38c03a | 187 | %token EQUAL "=" |
3d38c03a | 188 | %token ID "identifier" |
b7295522 | 189 | %token ID_COLON "identifier:" |
e9955c83 | 190 | %token PERCENT_PERCENT "%%" |
58d7a1a1 | 191 | %token PIPE "|" |
3d38c03a | 192 | %token PROLOGUE "%{...%}" |
58d7a1a1 AD |
193 | %token SEMICOLON ";" |
194 | %token TYPE "type" | |
12e35840 | 195 | %token TYPE_TAG_ANY "<*>" |
3ebecc24 | 196 | %token TYPE_TAG_NONE "<>" |
58d7a1a1 AD |
197 | |
198 | %type <character> CHAR | |
33ad1a9c | 199 | %printer { fputs (char_name ($$), stderr); } CHAR |
3d38c03a | 200 | |
2ce4ed68 | 201 | /* braceless is not to be used for rule or symbol actions, as it |
7c0c6181 | 202 | calls code_props_plain_init. */ |
6afc30cc | 203 | %type <chars> STRING "%{...%}" EPILOGUE braceless content.opt |
eb095650 | 204 | %type <code> "{...}" |
33ad1a9c | 205 | %printer { fputs (quotearg_style (c_quoting_style, $$), stderr); } |
eb095650 | 206 | STRING |
2ce4ed68 | 207 | %printer { fprintf (stderr, "{\n%s\n}", $$); } |
6afc30cc | 208 | braceless content.opt "{...}" "%{...%}" EPILOGUE |
58d7a1a1 | 209 | |
42ec0ae1 JD |
210 | %type <uniqstr> BRACKETED_ID ID ID_COLON TYPE variable |
211 | %printer { fputs ($$, stderr); } <uniqstr> | |
212 | %printer { fprintf (stderr, "[%s]", $$); } BRACKETED_ID | |
58d7a1a1 | 213 | %printer { fprintf (stderr, "%s:", $$); } ID_COLON |
42ec0ae1 | 214 | %printer { fprintf (stderr, "<%s>", $$); } TYPE |
58d7a1a1 | 215 | |
e9955c83 | 216 | %type <integer> INT |
42ec0ae1 | 217 | %printer { fprintf (stderr, "%d", $$); } <integer> |
58d7a1a1 | 218 | |
42ec0ae1 JD |
219 | %type <symbol> id id_colon string_as_id symbol symbol.prec |
220 | %printer { fprintf (stderr, "%s", $$->tag); } <symbol> | |
58d7a1a1 AD |
221 | %printer { fprintf (stderr, "%s:", $$->tag); } id_colon |
222 | ||
2c569025 | 223 | %type <assoc> precedence_declarator |
ab7f29f8 | 224 | %type <list> symbols.1 symbols.prec generic_symlist generic_symlist_item |
42ec0ae1 JD |
225 | %type <named_ref> named_ref.opt |
226 | ||
e9955c83 | 227 | %% |
2c569025 | 228 | |
8efe435c | 229 | input: |
2ce4ed68 | 230 | prologue_declarations "%%" grammar epilogue.opt |
e9955c83 AD |
231 | ; |
232 | ||
2c569025 AD |
233 | |
234 | /*------------------------------------. | |
235 | | Declarations: before the first %%. | | |
236 | `------------------------------------*/ | |
237 | ||
2ce4ed68 | 238 | prologue_declarations: |
e9955c83 | 239 | /* Nothing */ |
2ce4ed68 | 240 | | prologue_declarations prologue_declaration |
e9955c83 AD |
241 | ; |
242 | ||
2ce4ed68 | 243 | prologue_declaration: |
2c569025 | 244 | grammar_declaration |
7c0c6181 JD |
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 (); | |
7ecec4dd JD |
251 | muscle_code_grow (union_seen ? "post_prologue" : "pre_prologue", |
252 | plain_code.code, @1); | |
7c0c6181 JD |
253 | code_scanner_last_string_free (); |
254 | } | |
e0992e54 | 255 | | "%debug" { debug = true; } |
16dc6a9e | 256 | | "%define" variable content.opt |
7eb8a0bc | 257 | { |
34d41938 JD |
258 | muscle_percent_define_insert ($2, @2, $3, |
259 | MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE); | |
7eb8a0bc | 260 | } |
2ce4ed68 | 261 | | "%defines" { defines_flag = true; } |
02975b9a JD |
262 | | "%defines" STRING |
263 | { | |
264 | defines_flag = true; | |
265 | spec_defines_file = xstrdup ($2); | |
266 | } | |
2ce4ed68 AD |
267 | | "%error-verbose" { error_verbose = true; } |
268 | | "%expect" INT { expected_sr_conflicts = $2; } | |
269 | | "%expect-rr" INT { expected_rr_conflicts = $2; } | |
02975b9a JD |
270 | | "%file-prefix" STRING { spec_file_prefix = $2; } |
271 | | "%file-prefix" "=" STRING { spec_file_prefix = $3; } /* deprecated */ | |
cd3684cf | 272 | | "%glr-parser" |
c66dfadd PE |
273 | { |
274 | nondeterministic_parser = true; | |
275 | glr_parser = true; | |
276 | } | |
e9071366 | 277 | | "%initial-action" "{...}" |
c66dfadd | 278 | { |
7c0c6181 JD |
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 (); | |
c66dfadd | 285 | } |
e186a284 | 286 | | "%language" STRING { language_argmatch ($2, grammar_prio, @1); } |
2ce4ed68 AD |
287 | | "%lex-param" "{...}" { add_param ("lex_param", $2, @2); } |
288 | | "%locations" { locations_flag = true; } | |
02975b9a JD |
289 | | "%name-prefix" STRING { spec_name_prefix = $2; } |
290 | | "%name-prefix" "=" STRING { spec_name_prefix = $3; } /* deprecated */ | |
2ce4ed68 AD |
291 | | "%no-lines" { no_lines_flag = true; } |
292 | | "%nondeterministic-parser" { nondeterministic_parser = true; } | |
02975b9a JD |
293 | | "%output" STRING { spec_outfile = $2; } |
294 | | "%output" "=" STRING { spec_outfile = $3; } /* deprecated */ | |
2ce4ed68 | 295 | | "%parse-param" "{...}" { add_param ("parse_param", $2, @2); } |
d9df47b6 JD |
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)")) | |
34d41938 JD |
302 | muscle_percent_define_insert ("api.pure", @1, "", |
303 | MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE); | |
d9df47b6 JD |
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")) | |
34d41938 JD |
308 | muscle_percent_define_insert ("api.pure", @1, "", |
309 | MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE); | |
d9df47b6 | 310 | } |
2ce4ed68 | 311 | | "%require" STRING { version_check (&@2, $2); } |
a7867f53 JD |
312 | | "%skeleton" STRING |
313 | { | |
314 | char const *skeleton_user = $2; | |
d143e9c3 | 315 | if (mbschr (skeleton_user, '/')) |
a7867f53 JD |
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 | { | |
bb3b912b | 327 | memcpy (skeleton_build, current_file, dir_length); |
a7867f53 JD |
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 | } | |
e186a284 | 334 | skeleton_arg (skeleton_user, grammar_prio, @1); |
a7867f53 | 335 | } |
2ce4ed68 | 336 | | "%token-table" { token_table_flag = true; } |
ef1b4273 | 337 | | "%verbose" { report_flag |= report_states; } |
2ce4ed68 | 338 | | "%yacc" { yacc_flag = true; } |
cd3684cf | 339 | | /*FIXME: Err? What is this horror doing here? */ ";" |
e9955c83 AD |
340 | ; |
341 | ||
2c569025 AD |
342 | grammar_declaration: |
343 | precedence_declaration | |
344 | | symbol_declaration | |
e9955c83 AD |
345 | | "%start" symbol |
346 | { | |
8efe435c | 347 | grammar_start_symbol_set ($2, @2); |
e9955c83 | 348 | } |
3be03b13 | 349 | | "%destructor" "{...}" generic_symlist |
9280d3ef | 350 | { |
1c292035 AD |
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 | } | |
9280d3ef | 360 | } |
3be03b13 | 361 | | "%printer" "{...}" generic_symlist |
366eea36 | 362 | { |
1c292035 AD |
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 | } | |
366eea36 | 372 | } |
22fccf95 | 373 | | "%default-prec" |
39a06c25 | 374 | { |
22fccf95 PE |
375 | default_prec = true; |
376 | } | |
377 | | "%no-default-prec" | |
378 | { | |
379 | default_prec = false; | |
39a06c25 | 380 | } |
8e0a5e9e JD |
381 | | "%code" braceless |
382 | { | |
9611cfa2 JD |
383 | /* Do not invoke muscle_percent_code_grow here since it invokes |
384 | muscle_user_name_list_grow. */ | |
592d0b1e | 385 | muscle_code_grow ("percent_code()", $2, @2); |
8e0a5e9e JD |
386 | code_scanner_last_string_free (); |
387 | } | |
16dc6a9e | 388 | | "%code" ID braceless |
8e0a5e9e | 389 | { |
9611cfa2 | 390 | muscle_percent_code_grow ($2, @2, $3, @3); |
8e0a5e9e | 391 | code_scanner_last_string_free (); |
8e0a5e9e | 392 | } |
2c569025 AD |
393 | ; |
394 | ||
58d7a1a1 AD |
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: | |
7ecec4dd | 408 | "%union" union_name braceless |
58d7a1a1 | 409 | { |
ddc8ede1 | 410 | union_seen = true; |
7ecec4dd JD |
411 | muscle_code_grow ("stype", $3, @3); |
412 | code_scanner_last_string_free (); | |
58d7a1a1 AD |
413 | } |
414 | ; | |
415 | ||
416 | ||
417 | ||
418 | ||
2c569025 AD |
419 | symbol_declaration: |
420 | "%nterm" { current_class = nterm_sym; } symbol_defs.1 | |
e9955c83 AD |
421 | { |
422 | current_class = unknown_sym; | |
423 | current_type = NULL; | |
424 | } | |
2c569025 | 425 | | "%token" { current_class = token_sym; } symbol_defs.1 |
e9955c83 | 426 | { |
2c569025 | 427 | current_class = unknown_sym; |
e9955c83 AD |
428 | current_type = NULL; |
429 | } | |
1e0bab92 | 430 | | "%type" TYPE symbols.1 |
e9955c83 | 431 | { |
3d2cbc26 | 432 | symbol_list *list; |
4f82b42a | 433 | tag_seen = true; |
1e0bab92 | 434 | for (list = $3; list; list = list->next) |
3be03b13 | 435 | symbol_type_set (list->content.sym, $2, @2); |
dafdc66f | 436 | symbol_list_free ($3); |
e9955c83 AD |
437 | } |
438 | ; | |
439 | ||
2c569025 | 440 | precedence_declaration: |
ab7f29f8 | 441 | precedence_declarator type.opt symbols.prec |
1e0bab92 | 442 | { |
3d2cbc26 | 443 | symbol_list *list; |
1e0bab92 AD |
444 | ++current_prec; |
445 | for (list = $3; list; list = list->next) | |
446 | { | |
3be03b13 JD |
447 | symbol_type_set (list->content.sym, current_type, @2); |
448 | symbol_precedence_set (list->content.sym, current_prec, $1, @1); | |
1e0bab92 | 449 | } |
dafdc66f | 450 | symbol_list_free ($3); |
1e0bab92 AD |
451 | current_type = NULL; |
452 | } | |
e9955c83 AD |
453 | ; |
454 | ||
2c569025 | 455 | precedence_declarator: |
e9955c83 AD |
456 | "%left" { $$ = left_assoc; } |
457 | | "%right" { $$ = right_assoc; } | |
458 | | "%nonassoc" { $$ = non_assoc; } | |
459 | ; | |
460 | ||
461 | type.opt: | |
87fbb0bf | 462 | /* Nothing. */ { current_type = NULL; } |
ddc8ede1 | 463 | | TYPE { current_type = $1; tag_seen = true; } |
e9955c83 AD |
464 | ; |
465 | ||
ab7f29f8 JD |
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 | ||
3be03b13 | 479 | /* One or more symbols to be %typed. */ |
1e0bab92 | 480 | symbols.1: |
3be03b13 JD |
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); } | |
12e35840 | 495 | | "<*>" { $$ = symbol_list_default_tagged_new (@1); } |
3ebecc24 | 496 | | "<>" { $$ = symbol_list_default_tagless_new (@1); } |
e9955c83 AD |
497 | ; |
498 | ||
e9955c83 AD |
499 | /* One token definition. */ |
500 | symbol_def: | |
501 | TYPE | |
502 | { | |
503 | current_type = $1; | |
ddc8ede1 | 504 | tag_seen = true; |
e9955c83 | 505 | } |
58d7a1a1 | 506 | | id |
e9955c83 | 507 | { |
073f9288 | 508 | symbol_class_set ($1, current_class, @1, true); |
1a31ed21 | 509 | symbol_type_set ($1, current_type, @1); |
e9955c83 | 510 | } |
58d7a1a1 | 511 | | id INT |
e9955c83 | 512 | { |
073f9288 | 513 | symbol_class_set ($1, current_class, @1, true); |
1a31ed21 | 514 | symbol_type_set ($1, current_type, @1); |
e776192e | 515 | symbol_user_token_number_set ($1, $2, @2); |
e9955c83 | 516 | } |
58d7a1a1 | 517 | | id string_as_id |
e9955c83 | 518 | { |
073f9288 | 519 | symbol_class_set ($1, current_class, @1, true); |
1a31ed21 | 520 | symbol_type_set ($1, current_type, @1); |
a5d50994 | 521 | symbol_make_alias ($1, $2, @$); |
e9955c83 | 522 | } |
58d7a1a1 | 523 | | id INT string_as_id |
e9955c83 | 524 | { |
073f9288 | 525 | symbol_class_set ($1, current_class, @1, true); |
1a31ed21 | 526 | symbol_type_set ($1, current_type, @1); |
e776192e | 527 | symbol_user_token_number_set ($1, $2, @2); |
a5d50994 | 528 | symbol_make_alias ($1, $3, @$); |
e9955c83 AD |
529 | } |
530 | ; | |
531 | ||
532 | /* One or more symbol definitions. */ | |
533 | symbol_defs.1: | |
534 | symbol_def | |
e9955c83 | 535 | | symbol_defs.1 symbol_def |
e9955c83 AD |
536 | ; |
537 | ||
2c569025 AD |
538 | |
539 | /*------------------------------------------. | |
540 | | The grammar section: between the two %%. | | |
541 | `------------------------------------------*/ | |
542 | ||
543 | grammar: | |
1921f1d7 AD |
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 | |
b7295522 | 549 | body of the grammar. */ |
1921f1d7 | 550 | rules_or_grammar_declaration: |
e9955c83 | 551 | rules |
8d0a98bb | 552 | | grammar_declaration ";" |
b275314e AD |
553 | | error ";" |
554 | { | |
555 | yyerrok; | |
556 | } | |
e9955c83 AD |
557 | ; |
558 | ||
559 | rules: | |
8f462efe AD |
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 | } | |
e9955c83 AD |
565 | ; |
566 | ||
567 | rhses.1: | |
8f3596a6 AD |
568 | rhs { grammar_current_rule_end (@1); } |
569 | | rhses.1 "|" rhs { grammar_current_rule_end (@3); } | |
8d0a98bb | 570 | | rhses.1 ";" |
e9955c83 AD |
571 | ; |
572 | ||
573 | rhs: | |
574 | /* Nothing. */ | |
8f462efe | 575 | { grammar_current_rule_begin (current_lhs_symbol, current_lhs_location, |
7685e2f7 AR |
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); } | |
e9955c83 | 581 | | rhs "%prec" symbol |
e776192e | 582 | { grammar_current_rule_prec_set ($3, @3); } |
676385e2 PH |
583 | | rhs "%dprec" INT |
584 | { grammar_current_rule_dprec_set ($3, @3); } | |
585 | | rhs "%merge" TYPE | |
586 | { grammar_current_rule_merge_set ($3, @3); } | |
e9955c83 AD |
587 | ; |
588 | ||
7685e2f7 | 589 | named_ref.opt: |
d5e8574b | 590 | /* Nothing. */ { $$ = 0; } |
7685e2f7 | 591 | | |
d5e8574b | 592 | BRACKETED_ID { $$ = named_ref_new($1, @1); } |
7685e2f7 AR |
593 | ; |
594 | ||
58d7a1a1 | 595 | |
16dc6a9e JD |
596 | /*----------------------------* |
597 | | variable and content.opt. | | |
598 | *---------------------------*/ | |
599 | ||
ae618dcc JD |
600 | /* The STRING form of variable is deprecated and is not M4-friendly. |
601 | For example, M4 fails for `%define "[" "value"'. */ | |
16dc6a9e JD |
602 | variable: |
603 | ID | |
663ce7bb AD |
604 | | STRING { $$ = uniqstr_new ($1); } |
605 | ; | |
2ce4ed68 | 606 | |
592d0b1e | 607 | /* Some content or empty by default. */ |
2ce4ed68 | 608 | content.opt: |
663ce7bb | 609 | /* Nothing. */ { $$ = ""; } |
f37495f6 | 610 | | ID { $$ = $1; } |
6afc30cc | 611 | | STRING |
2ce4ed68 AD |
612 | ; |
613 | ||
614 | ||
6afc30cc JD |
615 | /*-------------* |
616 | | braceless. | | |
617 | *-------------*/ | |
618 | ||
2ce4ed68 AD |
619 | braceless: |
620 | "{...}" | |
621 | { | |
7c0c6181 | 622 | code_props plain_code; |
2ce4ed68 | 623 | $1[strlen ($1) - 1] = '\n'; |
7c0c6181 JD |
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; | |
2ce4ed68 AD |
628 | } |
629 | ; | |
630 | ||
631 | ||
58d7a1a1 AD |
632 | /*---------------* |
633 | | Identifiers. | | |
634 | *---------------*/ | |
635 | ||
33ad1a9c PE |
636 | /* Identifiers are returned as uniqstr values by the scanner. |
637 | Depending on their use, we may need to make them genuine symbols. */ | |
58d7a1a1 AD |
638 | |
639 | id: | |
33ad1a9c | 640 | ID |
203b9274 | 641 | { $$ = symbol_from_uniqstr ($1, @1); } |
33ad1a9c PE |
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 | } | |
58d7a1a1 AD |
648 | ; |
649 | ||
650 | id_colon: | |
203b9274 | 651 | ID_COLON { $$ = symbol_from_uniqstr ($1, @1); } |
58d7a1a1 AD |
652 | ; |
653 | ||
654 | ||
e9955c83 | 655 | symbol: |
58d7a1a1 AD |
656 | id |
657 | | string_as_id | |
e9955c83 AD |
658 | ; |
659 | ||
ca407bdf | 660 | /* A string used as an ID: quote it. */ |
e9955c83 AD |
661 | string_as_id: |
662 | STRING | |
663 | { | |
ca407bdf | 664 | $$ = symbol_get (quotearg_style (c_quoting_style, $1), @1); |
db89d400 | 665 | symbol_class_set ($$, token_sym, @1, false); |
e9955c83 AD |
666 | } |
667 | ; | |
668 | ||
e9955c83 AD |
669 | epilogue.opt: |
670 | /* Nothing. */ | |
e9955c83 AD |
671 | | "%%" EPILOGUE |
672 | { | |
7c0c6181 JD |
673 | code_props plain_code; |
674 | code_props_plain_init (&plain_code, $2, @2); | |
675 | code_props_translate_code (&plain_code); | |
e9071366 | 676 | gram_scanner_last_string_free (); |
7c0c6181 JD |
677 | muscle_code_grow ("epilogue", plain_code.code, @2); |
678 | code_scanner_last_string_free (); | |
e9955c83 AD |
679 | } |
680 | ; | |
681 | ||
e9955c83 | 682 | %% |
b7295522 PE |
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; | |
a737b216 | 694 | YYLTYPE loc; |
62cb8a99 PE |
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; | |
b7295522 | 700 | |
77315a51 | 701 | /* Ignore empty nonterminals the start of the right-hand side. |
5320ca4d PE |
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. */ | |
b7295522 PE |
704 | for (i = 1; i <= n; i++) |
705 | if (! equal_boundaries (rhs[i].start, rhs[i].end)) | |
706 | { | |
a737b216 | 707 | loc.start = rhs[i].start; |
b7295522 PE |
708 | break; |
709 | } | |
710 | ||
a737b216 | 711 | return loc; |
b7295522 PE |
712 | } |
713 | ||
714 | ||
715 | /* Add a lex-param or a parse-param (depending on TYPE) with | |
716 | declaration DECL and location LOC. */ | |
717 | ||
1773ceee | 718 | static void |
e9ce5688 | 719 | add_param (char const *type, char *decl, location loc) |
1773ceee | 720 | { |
ead9e56e | 721 | static char const alphanum[26 + 26 + 1 + 10] = |
1773ceee PE |
722 | "abcdefghijklmnopqrstuvwxyz" |
723 | "ABCDEFGHIJKLMNOPQRSTUVWXYZ" | |
ead9e56e PE |
724 | "_" |
725 | "0123456789"; | |
1773ceee | 726 | char const *name_start = NULL; |
e9ce5688 | 727 | char *p; |
1773ceee | 728 | |
e503aa60 AD |
729 | /* Stop on last actual character. */ |
730 | for (p = decl; p[1]; p++) | |
ead9e56e PE |
731 | if ((p == decl |
732 | || ! memchr (alphanum, p[-1], sizeof alphanum)) | |
733 | && memchr (alphanum, p[0], sizeof alphanum - 10)) | |
1773ceee PE |
734 | name_start = p; |
735 | ||
ead9e56e PE |
736 | /* Strip the surrounding '{' and '}', and any blanks just inside |
737 | the braces. */ | |
c9d546b2 | 738 | --p; |
457bf919 | 739 | while (c_isspace ((unsigned char) *p)) |
c9d546b2 | 740 | --p; |
e503aa60 | 741 | p[1] = '\0'; |
c9d546b2 | 742 | ++decl; |
457bf919 | 743 | while (c_isspace ((unsigned char) *decl)) |
c9d546b2 | 744 | ++decl; |
e9ce5688 | 745 | |
1773ceee PE |
746 | if (! name_start) |
747 | complain_at (loc, _("missing identifier in parameter declaration")); | |
748 | else | |
749 | { | |
60457f30 | 750 | char *name = xmemdup0 (name_start, strspn (name_start, alphanum)); |
1773ceee PE |
751 | muscle_pair_list_grow (type, decl, name); |
752 | free (name); | |
753 | } | |
754 | ||
e9071366 | 755 | gram_scanner_last_string_free (); |
1773ceee PE |
756 | } |
757 | ||
2ce4ed68 | 758 | |
b50d2359 AD |
759 | static void |
760 | version_check (location const *loc, char const *version) | |
761 | { | |
762 | if (strverscmp (version, PACKAGE_VERSION) > 0) | |
9b8a5ce0 AD |
763 | { |
764 | complain_at (*loc, "require bison %s, but have %s", | |
dd561157 | 765 | version, PACKAGE_VERSION); |
da209f94 | 766 | exit (EX_MISMATCH); |
9b8a5ce0 | 767 | } |
b50d2359 AD |
768 | } |
769 | ||
1fec91df | 770 | static void |
3d2cbc26 | 771 | gram_error (location const *loc, char const *msg) |
e9955c83 | 772 | { |
ad8a3efc | 773 | complain_at (*loc, "%s", msg); |
e9955c83 | 774 | } |
e9ce5688 PE |
775 | |
776 | char const * | |
777 | token_name (int type) | |
778 | { | |
fc01665e | 779 | return yytname[YYTRANSLATE (type)]; |
e9ce5688 | 780 | } |
33ad1a9c PE |
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 | } |