X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/7ec2d4cd3932bfba78e9fbd52509d9f80b61c8ef..985d7177e8aaedcabe48dd911077ddcc8f74891f:/src/parse-gram.y diff --git a/src/parse-gram.y b/src/parse-gram.y index c10c82ac..4c87c909 100644 --- a/src/parse-gram.y +++ b/src/parse-gram.y @@ -1,11 +1,12 @@ /* Bison Grammar Parser -*- C -*- - Copyright (C) 2002 Free Software Foundation, Inc. + + Copyright (C) 2002-2013 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. - This program is free software; you can redistribute it and/or modify + This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -14,91 +15,101 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 USA -*/ + along with this program. If not, see . */ +%code requires +{ + #include "symlist.h" + #include "symtab.h" +} -%debug -%defines -%locations -%pure-parser -// %error-verbose +%code +{ + #include + #include "system.h" + + #include "c-ctype.h" + #include "complain.h" + #include "conflicts.h" + #include "files.h" + #include "getargs.h" + #include "gram.h" + #include "named-ref.h" + #include "quotearg.h" + #include "reader.h" + #include "scan-gram.h" + #include "scan-code.h" + #include "xmemdup0.h" + + static int current_prec = 0; + static location current_lhs_location; + static named_ref *current_lhs_named_ref; + static symbol *current_lhs_symbol; + static symbol_class current_class = unknown_sym; + static uniqstr current_type = NULL; + + /** Set the new current left-hand side symbol, possibly common + * to several right-hand side parts of rule. + */ + static void current_lhs (symbol *sym, location loc, named_ref *ref); + + #define YYLLOC_DEFAULT(Current, Rhs, N) \ + (Current) = lloc_default (Rhs, N) + static YYLTYPE lloc_default (YYLTYPE const *, int); + + #define YY_LOCATION_PRINT(File, Loc) \ + location_print (Loc, File) + + /* Strip initial '{' and final '}' (must be first and last characters). + Return the result. */ + static char *strip_braces (char *code); + + /* Convert CODE by calling code_props_plain_init if PLAIN, otherwise + code_props_symbol_action_init. Call + gram_scanner_last_string_free to release the latest string from + the scanner (should be CODE). */ + static char const *translate_code (char *code, location loc, bool plain); + + /* Convert CODE by calling code_props_plain_init after having + stripped the first and last characters (expected to be '{', and + '}'). Call gram_scanner_last_string_free to release the latest + string from the scanner (should be CODE). */ + static char const *translate_code_braceless (char *code, location loc); + + static void version_check (location const *loc, char const *version); + + static void gram_error (location const *, char const *); + + /* A string that describes a char (e.g., 'a' -> "'a'"). */ + static char const *char_name (char); + + #define YYTYPE_INT16 int_fast16_t + #define YYTYPE_INT8 int_fast8_t + #define YYTYPE_UINT16 uint_fast16_t + #define YYTYPE_UINT8 uint_fast8_t +} + +%define api.prefix {gram_} +%define api.pure full +%define locations +%define parse.error verbose +%define parse.lac full +%define parse.trace %defines -%name-prefix="gram_" - -%{ -#include "system.h" -#include "complain.h" -#include "muscle_tab.h" -#include "files.h" -#include "getargs.h" -#include "output.h" -#include "symlist.h" -#include "gram.h" -#include "reader.h" -#include "conflicts.h" - -/* Produce verbose parse errors. */ -#define YYERROR_VERBOSE 1 -#define YYLLOC_DEFAULT(Current, Rhs, N) \ -do { \ - if (N) \ - { \ - Current.first_column = Rhs[1].first_column; \ - Current.first_line = Rhs[1].first_line; \ - Current.last_column = Rhs[N].last_column; \ - Current.last_line = Rhs[N].last_line; \ - } \ - else \ - { \ - Current = Rhs[0]; \ - } \ -} while (0) - -/* Pass the control structure to YYPARSE and YYLEX. */ -#define YYPARSE_PARAM gram_control -#define YYLEX_PARAM gram_control -/* YYPARSE receives GRAM_CONTROL as a void *. Provide a - correctly typed access to it. */ -#define yycontrol ((gram_control_t *) gram_control) - -/* Request detailed parse error messages, and pass them to GRAM_ERROR. - FIXME: depends on the undocumented availability of YYLLOC.t */ -#undef yyerror -#define yyerror(Msg) \ - gram_error (&yylloc, Msg) - -#define YYPRINT(File, Type, Value) \ - yyprint (File, Type, &Value) -static void yyprint (FILE *file, int type, const yystype *value); - -symbol_class current_class = unknown_sym; -struniq_t current_type = 0; -symbol_t *current_lhs; -location_t current_lhs_location; -assoc_t current_assoc; -int current_prec = 0; -braced_code_t current_braced_code = action_braced_code; -%} - - -/* Only NUMBERS have a value. */ -%union +%expect 0 +%verbose + +%initial-action { - symbol_t *symbol; - symbol_list_t *list; - int integer; - char *string; - assoc_t assoc; - struniq_t struniq; -}; + /* Bison's grammar can initial empty locations, hence a default + location is needed. */ + boundary_set (&@$.start, current_file, 1, 1); + boundary_set (&@$.end, current_file, 1, 1); +} /* Define the tokens together with their human representation. */ %token GRAM_EOF 0 "end of file" %token STRING "string" -%token INT "integer" %token PERCENT_TOKEN "%token" %token PERCENT_NTERM "%nterm" @@ -107,108 +118,246 @@ braced_code_t current_braced_code = action_braced_code; %token PERCENT_DESTRUCTOR "%destructor" %token PERCENT_PRINTER "%printer" -%token PERCENT_UNION "%union" - %token PERCENT_LEFT "%left" %token PERCENT_RIGHT "%right" %token PERCENT_NONASSOC "%nonassoc" +%token PERCENT_PRECEDENCE "%precedence" %token PERCENT_PREC "%prec" %token PERCENT_DPREC "%dprec" %token PERCENT_MERGE "%merge" - /*----------------------. | Global Declarations. | `----------------------*/ %token - PERCENT_DEBUG "%debug" - PERCENT_DEFINE "%define" - PERCENT_DEFINES "%defines" - PERCENT_ERROR_VERBOSE "%error-verbose" - PERCENT_EXPECT "%expect" - PERCENT_FILE_PREFIX "%file-prefix" - PERCENT_GLR_PARSER "%glr-parser" - PERCENT_LEX_PARAM "%lex-param" - PERCENT_LOCATIONS "%locations" - PERCENT_NAME_PREFIX "%name-prefix" - PERCENT_NO_LINES "%no-lines" - PERCENT_OUTPUT "%output" - PERCENT_PARSE_PARAM "%parse-param" - PERCENT_PURE_PARSER "%pure-parser" - PERCENT_SKELETON "%skeleton" - PERCENT_START "%start" - PERCENT_TOKEN_TABLE "%token-table" - PERCENT_VERBOSE "%verbose" - PERCENT_YACC "%yacc" -; - -%token TYPE "type" + PERCENT_CODE "%code" + PERCENT_DEFAULT_PREC "%default-prec" + PERCENT_DEFINE "%define" + PERCENT_DEFINES "%defines" + PERCENT_ERROR_VERBOSE "%error-verbose" + PERCENT_EXPECT "%expect" + PERCENT_EXPECT_RR "%expect-rr" + PERCENT_FLAG "%" + PERCENT_FILE_PREFIX "%file-prefix" + PERCENT_GLR_PARSER "%glr-parser" + PERCENT_INITIAL_ACTION "%initial-action" + PERCENT_LANGUAGE "%language" + PERCENT_NAME_PREFIX "%name-prefix" + PERCENT_NO_DEFAULT_PREC "%no-default-prec" + PERCENT_NO_LINES "%no-lines" + PERCENT_NONDETERMINISTIC_PARSER + "%nondeterministic-parser" + PERCENT_OUTPUT "%output" + PERCENT_REQUIRE "%require" + PERCENT_SKELETON "%skeleton" + PERCENT_START "%start" + PERCENT_TOKEN_TABLE "%token-table" + PERCENT_VERBOSE "%verbose" + PERCENT_YACC "%yacc" +; + +%token BRACED_CODE "{...}" +%token BRACED_PREDICATE "%?{...}" +%token BRACKETED_ID "[identifier]" +%token CHAR "char" +%token EPILOGUE "epilogue" %token EQUAL "=" -%token SEMICOLON ";" -%token COLON ":" -%token COMMA "," -%token PIPE "|" %token ID "identifier" +%token ID_COLON "identifier:" %token PERCENT_PERCENT "%%" +%token PIPE "|" %token PROLOGUE "%{...%}" -%token EPILOGUE "epilogue" -%token BRACED_CODE "{...}" +%token SEMICOLON ";" +%token TAG "" +%token TAG_ANY "<*>" +%token TAG_NONE "<>" + +%union {unsigned char character;} +%type CHAR +%printer { fputs (char_name ($$), yyo); } CHAR + +%union {char *code;}; +%type "{...}" "%?{...}" "%{...%}" EPILOGUE STRING +%printer { fputs (quotearg_style (c_quoting_style, $$), yyo); } STRING +%printer { fprintf (yyo, "{\n%s\n}", $$); } + +%union {uniqstr uniqstr;} +%type BRACKETED_ID ID ID_COLON PERCENT_FLAG TAG tag variable +%printer { fputs ($$, yyo); } +%printer { fprintf (yyo, "[%s]", $$); } BRACKETED_ID +%printer { fprintf (yyo, "%s:", $$); } ID_COLON +%printer { fprintf (yyo, "%%%s", $$); } PERCENT_FLAG +%printer { fprintf (yyo, "<%s>", $$); } TAG tag + +%union {int integer;}; +%token INT "integer" +%printer { fprintf (yyo, "%d", $$); } + +%union {symbol *symbol;} +%type id id_colon string_as_id symbol symbol.prec +%printer { fprintf (yyo, "%s", $$->tag); } +%printer { fprintf (yyo, "%s:", $$->tag); } id_colon + +%union {assoc assoc;}; +%type precedence_declarator +%union {symbol_list *list;} +%type symbols.1 symbols.prec generic_symlist generic_symlist_item -%type STRING string_content - BRACED_CODE action - PROLOGUE EPILOGUE -%type TYPE -%type INT -%type ID symbol string_as_id -%type precedence_declarator -%type symbols.1 -%% +%union {named_ref *named_ref;} +%type named_ref.opt -input: - declarations "%%" grammar epilogue.opt +/*---------. +| %param. | +`---------*/ +%code requires +{ + typedef enum + { + param_none = 0, + param_lex = 1 << 0, + param_parse = 1 << 1, + param_both = param_lex | param_parse + } param_type; +}; +%code +{ + /** Add a lex-param and/or a parse-param. + * + * \param type where to push this formal argument. + * \param decl the formal argument. Destroyed. + * \param loc the location in the source. + */ + static void add_param (param_type type, char *decl, location loc); + static param_type current_param = param_none; +}; +%union {param_type param;} +%token PERCENT_PARAM "%param"; +%printer +{ + switch ($$) { - yycontrol->errcode = 0; +#define CASE(In, Out) \ + case param_ ## In: fputs ("%" #Out, yyo); break + CASE (lex, lex-param); + CASE (parse, parse-param); + CASE (both, param); +#undef CASE + case param_none: aver (false); break; } +} ; + + + /*==========\ + | Grammar. | + \==========*/ +%% + +input: + prologue_declarations "%%" grammar epilogue.opt ; - /*------------------------------------. - | Declarations: before the first %%. | - `------------------------------------*/ + /*------------------------------------. + | Declarations: before the first %%. | + `------------------------------------*/ -declarations: - /* Nothing */ -| declarations declaration semi_colon.opt +prologue_declarations: + %empty +| prologue_declarations prologue_declaration ; -declaration: +prologue_declaration: grammar_declaration -| PROLOGUE { prologue_augment ($1, @1); } -| "%debug" { debug_flag = 1; } -| "%define" string_content string_content { muscle_insert ($2, $3); } -| "%defines" { defines_flag = 1; } -| "%error-verbose" { error_verbose = 1; } -| "%expect" INT { expected_conflicts = $2; } -| "%file-prefix" "=" string_content { spec_file_prefix = $3; } -| "%glr-parser" { glr_parser = 1; } -| "%lex-param" string_content "," string_content - { muscle_pair_list_grow ("lex_param", $2, $4); } -| "%locations" { locations_flag = 1; } -| "%name-prefix" "=" string_content { spec_name_prefix = $3; } -| "%no-lines" { no_lines_flag = 1; } -| "%output" "=" string_content { spec_outfile = $3; } -| "%parse-param" string_content "," string_content - { muscle_pair_list_grow ("parse_param", $2, $4); } -| "%pure-parser" { pure_parser = 1; } -| "%skeleton" string_content { skeleton = $2; } -| "%token-table" { token_table_flag = 1; } -| "%verbose" { report_flag = 1; } -| "%yacc" { yacc_flag = 1; } +| "%{...%}" + { + muscle_code_grow (union_seen ? "post_prologue" : "pre_prologue", + translate_code ($1, @1, true), @1); + code_scanner_last_string_free (); + } +| "%" + { + muscle_percent_define_ensure ($1, @1, true); + } +| "%define" variable value + { + muscle_percent_define_insert ($2, @2, $3.kind, $3.chars, + MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE); + } +| "%defines" { defines_flag = true; } +| "%defines" STRING + { + defines_flag = true; + spec_defines_file = xstrdup ($2); + } +| "%error-verbose" + { + muscle_percent_define_insert ("parse.error", @1, muscle_keyword, + "verbose", + MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE); + } +| "%expect" INT { expected_sr_conflicts = $2; } +| "%expect-rr" INT { expected_rr_conflicts = $2; } +| "%file-prefix" STRING { spec_file_prefix = $2; } +| "%glr-parser" + { + nondeterministic_parser = true; + glr_parser = true; + } +| "%initial-action" "{...}" + { + muscle_code_grow ("initial_action", translate_code ($2, @2, false), @2); + code_scanner_last_string_free (); + } +| "%language" STRING { language_argmatch ($2, grammar_prio, @1); } +| "%name-prefix" STRING { spec_name_prefix = $2; } +| "%no-lines" { no_lines_flag = true; } +| "%nondeterministic-parser" { nondeterministic_parser = true; } +| "%output" STRING { spec_outfile = $2; } +| "%param" { current_param = $1; } params { current_param = param_none; } +| "%require" STRING { version_check (&@2, $2); } +| "%skeleton" STRING + { + char const *skeleton_user = $2; + if (strchr (skeleton_user, '/')) + { + size_t dir_length = strlen (current_file); + char *skeleton_build; + while (dir_length && current_file[dir_length - 1] != '/') + --dir_length; + while (dir_length && current_file[dir_length - 1] == '/') + --dir_length; + skeleton_build = + xmalloc (dir_length + 1 + strlen (skeleton_user) + 1); + if (dir_length > 0) + { + memcpy (skeleton_build, current_file, dir_length); + skeleton_build[dir_length++] = '/'; + } + strcpy (skeleton_build + dir_length, skeleton_user); + skeleton_user = uniqstr_new (skeleton_build); + free (skeleton_build); + } + skeleton_arg (skeleton_user, grammar_prio, @1); + } +| "%token-table" { token_table_flag = true; } +| "%verbose" { report_flag |= report_states; } +| "%yacc" { yacc_flag = true; } +| /*FIXME: Err? What is this horror doing here? */ ";" ; +params: + params "{...}" { add_param (current_param, $2, @2); } +| "{...}" { add_param (current_param, $1, @1); } +; + + +/*----------------------. +| grammar_declaration. | +`----------------------*/ + grammar_declaration: precedence_declaration | symbol_declaration @@ -216,34 +365,72 @@ grammar_declaration: { grammar_start_symbol_set ($2, @2); } -| "%union" BRACED_CODE +| code_props_type "{...}" generic_symlist + { + code_props code; + code_props_symbol_action_init (&code, $2, @2); + code_props_translate_code (&code); + { + symbol_list *list; + for (list = $3; list; list = list->next) + symbol_list_code_props_set (list, $1, &code); + symbol_list_free ($3); + } + } +| "%default-prec" + { + default_prec = true; + } +| "%no-default-prec" { - typed = 1; - MUSCLE_INSERT_INT ("stype_line", @2.first_line); - muscle_insert ("stype", $2); + default_prec = false; } -| "%destructor" - { current_braced_code = destructor_braced_code; } - BRACED_CODE symbols.1 +| "%code" "{...}" { - symbol_list_t *list; - for (list = $4; list; list = list->next) - symbol_destructor_set (list->sym, $3, @3); - symbol_list_free ($4); - current_braced_code = action_braced_code; + /* Do not invoke muscle_percent_code_grow here since it invokes + muscle_user_name_list_grow. */ + muscle_code_grow ("percent_code()", + translate_code_braceless ($2, @2), @2); + code_scanner_last_string_free (); } -| "%printer" - { current_braced_code = printer_braced_code; } - BRACED_CODE symbols.1 +| "%code" ID "{...}" { - symbol_list_t *list; - for (list = $4; list; list = list->next) - symbol_printer_set (list->sym, $3, list->location); - symbol_list_free ($4); - current_braced_code = action_braced_code; + muscle_percent_code_grow ($2, @2, translate_code_braceless ($3, @3), @3); + code_scanner_last_string_free (); } ; +%type code_props_type; +%union {code_props_type code_type;}; +%printer { fprintf (yyo, "%s", code_props_type_string ($$)); } ; +code_props_type: + "%destructor" { $$ = destructor; } +| "%printer" { $$ = printer; } +; + +/*---------. +| %union. | +`---------*/ + +%token PERCENT_UNION "%union"; + +union_name: + %empty {} +| ID { muscle_code_grow ("union_name", $1, @1); } +; + +grammar_declaration: + "%union" union_name "{...}" + { + union_seen = true; + muscle_code_grow ("union_members", translate_code_braceless ($3, @3), @3); + code_scanner_last_string_free (); + } +; + + + + symbol_declaration: "%nterm" { current_class = nterm_sym; } symbol_defs.1 { @@ -255,74 +442,116 @@ symbol_declaration: current_class = unknown_sym; current_type = NULL; } -| "%type" TYPE symbols.1 +| "%type" TAG symbols.1 { - symbol_list_t *list; + symbol_list *list; + tag_seen = true; for (list = $3; list; list = list->next) - symbol_type_set (list->sym, $2, @2); + symbol_type_set (list->content.sym, $2, @2); symbol_list_free ($3); } ; precedence_declaration: - precedence_declarator type.opt symbols.1 + precedence_declarator tag.opt symbols.prec { - symbol_list_t *list; + symbol_list *list; ++current_prec; for (list = $3; list; list = list->next) - { - symbol_type_set (list->sym, current_type, @2); - symbol_precedence_set (list->sym, current_prec, $1, @1); - } + { + symbol_type_set (list->content.sym, current_type, @2); + symbol_precedence_set (list->content.sym, current_prec, $1, @1); + } symbol_list_free ($3); current_type = NULL; } ; precedence_declarator: - "%left" { $$ = left_assoc; } -| "%right" { $$ = right_assoc; } -| "%nonassoc" { $$ = non_assoc; } + "%left" { $$ = left_assoc; } +| "%right" { $$ = right_assoc; } +| "%nonassoc" { $$ = non_assoc; } +| "%precedence" { $$ = precedence_assoc; } ; -type.opt: - /* Nothing. */ { current_type = NULL; } -| TYPE { current_type = $1; } +tag.opt: + %empty { current_type = NULL; } +| TAG { current_type = $1; tag_seen = true; } ; -/* One or more nonterminals to be %typed. */ +/* Just like symbols.1 but accept INT for the sake of POSIX. */ +symbols.prec: + symbol.prec + { $$ = symbol_list_sym_new ($1, @1); } +| symbols.prec symbol.prec + { $$ = symbol_list_append ($1, symbol_list_sym_new ($2, @2)); } +; + +symbol.prec: + symbol + { + $$ = $1; + symbol_class_set ($1, token_sym, @1, false); + } +| symbol INT + { + $$ = $1; + symbol_user_token_number_set ($1, $2, @2); + symbol_class_set ($1, token_sym, @1, false); + } +; +/* One or more symbols to be %typed. */ symbols.1: - symbol { $$ = symbol_list_new ($1, @1); } -| symbols.1 symbol { $$ = symbol_list_prepend ($1, $2, @2); } + symbol + { $$ = symbol_list_sym_new ($1, @1); } +| symbols.1 symbol + { $$ = symbol_list_append ($1, symbol_list_sym_new ($2, @2)); } +; + +generic_symlist: + generic_symlist_item { $$ = $1; } +| generic_symlist generic_symlist_item { $$ = symbol_list_append ($1, $2); } +; + +generic_symlist_item: + symbol { $$ = symbol_list_sym_new ($1, @1); } +| tag { $$ = symbol_list_type_new ($1, @1); } +; + +tag: + TAG +| "<*>" { $$ = uniqstr_new ("*"); } +| "<>" { $$ = uniqstr_new (""); } ; /* One token definition. */ symbol_def: - TYPE - { - current_type = $1; - } -| ID - { - symbol_class_set ($1, current_class, @1); - symbol_type_set ($1, current_type, @1); - } -| ID INT - { - symbol_class_set ($1, current_class, @1); + TAG + { + current_type = $1; + tag_seen = true; + } +| id + { + symbol_class_set ($1, current_class, @1, true); + symbol_type_set ($1, current_type, @1); + } +| id INT + { + symbol_class_set ($1, current_class, @1, true); symbol_type_set ($1, current_type, @1); symbol_user_token_number_set ($1, $2, @2); } -| ID string_as_id +| id string_as_id { - symbol_class_set ($1, current_class, @1); + symbol_class_set ($1, current_class, @1, true); symbol_type_set ($1, current_type, @1); symbol_make_alias ($1, $2, @$); } -| ID INT string_as_id +| id INT string_as_id { - symbol_class_set ($1, current_class, @1); + symbol_class_set ($1, current_class, @1, true); symbol_type_set ($1, current_type, @1); symbol_user_token_number_set ($1, $2, @2); symbol_make_alias ($1, $3, @$); @@ -332,15 +561,13 @@ symbol_def: /* One or more symbol definitions. */ symbol_defs.1: symbol_def - {;} | symbol_defs.1 symbol_def - {;} ; - /*------------------------------------------. - | The grammar section: between the two %%. | - `------------------------------------------*/ + /*------------------------------------------. + | The grammar section: between the two %%. | + `------------------------------------------*/ grammar: rules_or_grammar_declaration @@ -348,15 +575,10 @@ grammar: ; /* As a Bison extension, one can use the grammar declarations in the - body of the grammar. But to remain LALR(1), they must be ended - with a semi-colon. */ + body of the grammar. */ rules_or_grammar_declaration: rules | grammar_declaration ";" - { - if (yacc_flag) - complain_at (@$, _("POSIX forbids declarations in the grammar")); - } | error ";" { yyerrok; @@ -364,113 +586,284 @@ rules_or_grammar_declaration: ; rules: - ID ":" { current_lhs = $1; current_lhs_location = @1; } rhses.1 ";" - {;} + id_colon named_ref.opt { current_lhs ($1, @1, $2); } rhses.1 + { + /* Free the current lhs. */ + current_lhs (0, @1, 0); + } ; rhses.1: - rhs { grammar_rule_end (@1); } -| rhses.1 "|" rhs { grammar_rule_end (@3); } + rhs { grammar_current_rule_end (@1); } +| rhses.1 "|" rhs { grammar_current_rule_end (@3); } +| rhses.1 ";" ; +%token PERCENT_EMPTY "%empty"; rhs: - /* Nothing. */ - { grammar_rule_begin (current_lhs, current_lhs_location); } -| rhs symbol - { grammar_current_rule_symbol_append ($2, @2); } -| rhs action - { grammar_current_rule_action_append ($2, @2); } + %empty + { grammar_current_rule_begin (current_lhs_symbol, current_lhs_location, + current_lhs_named_ref); } +| rhs symbol named_ref.opt + { grammar_current_rule_symbol_append ($2, @2, $3); } +| rhs "{...}" named_ref.opt + { grammar_current_rule_action_append ($2, @2, $3, false); } +| rhs "%?{...}" + { grammar_current_rule_action_append ($2, @2, NULL, true); } +| rhs "%empty" + { grammar_current_rule_empty_set (@2); } | rhs "%prec" symbol { grammar_current_rule_prec_set ($3, @3); } | rhs "%dprec" INT { grammar_current_rule_dprec_set ($3, @3); } -| rhs "%merge" TYPE +| rhs "%merge" TAG { grammar_current_rule_merge_set ($3, @3); } ; -symbol: - ID { $$ = $1; } -| string_as_id { $$ = $1; } +named_ref.opt: + %empty { $$ = 0; } +| BRACKETED_ID { $$ = named_ref_new($1, @1); } ; -action: - BRACED_CODE - { $$ = $1; } +/*---------------------. +| variable and value. | +`---------------------*/ + +/* The STRING form of variable is deprecated and is not M4-friendly. + For example, M4 fails for '%define "[" "value"'. */ +variable: + ID +| STRING { $$ = uniqstr_new ($1); } ; -/* A string used as an ID: we have to keep the quotes. */ -string_as_id: - STRING +/* Some content or empty by default. */ +%code requires {#include "muscle-tab.h"}; +%union +{ + struct + { + char const *chars; + muscle_kind kind; + } value; +}; +%type value; +%printer +{ + switch ($$.kind) { - $$ = symbol_get ($1, @1); - symbol_class_set ($$, token_sym, @1); + case muscle_code: fprintf (yyo, "{%s}", $$.chars); break; + case muscle_keyword: fprintf (yyo, "%s", $$.chars); break; + case muscle_string: fprintf (yyo, "\"%s\"", $$.chars); break; } +} ; + +value: + %empty { $$.kind = muscle_keyword; $$.chars = ""; } +| ID { $$.kind = muscle_keyword; $$.chars = $1; } +| STRING { $$.kind = muscle_string; $$.chars = $1; } +| "{...}" { $$.kind = muscle_code; + $$.chars = translate_code_braceless ($1, @1); } ; -/* A string used for its contents. Strip the quotes. */ -string_content: - STRING + +/*--------------. +| Identifiers. | +`--------------*/ + +/* Identifiers are returned as uniqstr values by the scanner. + Depending on their use, we may need to make them genuine symbols. */ + +id: + ID + { $$ = symbol_from_uniqstr ($1, @1); } +| CHAR { - $$ = $1 + 1; - $$[strlen ($$) - 1] = '\0'; - }; + $$ = symbol_get (char_name ($1), @1); + symbol_class_set ($$, token_sym, @1, false); + symbol_user_token_number_set ($$, $1, @1); + } +; + +id_colon: + ID_COLON { $$ = symbol_from_uniqstr ($1, @1); } +; +symbol: + id +| string_as_id +; + +/* A string used as an ID: quote it. */ +string_as_id: + STRING + { + $$ = symbol_get (quotearg_style (c_quoting_style, $1), @1); + symbol_class_set ($$, token_sym, @1, false); + } +; + epilogue.opt: - /* Nothing. */ + %empty | "%%" EPILOGUE { - epilogue_augment ($2, @2); - scanner_last_string_free (); + muscle_code_grow ("epilogue", translate_code ($2, @2, true), @2); + code_scanner_last_string_free (); } ; -semi_colon.opt: - /* Nothing. */ -| ";" -; %% -/*------------------------------------------------------------------. -| When debugging the parser, display tokens' locations and values. | -`------------------------------------------------------------------*/ + +/* Return the location of the left-hand side of a rule whose + right-hand side is RHS[1] ... RHS[N]. Ignore empty nonterminals in + the right-hand side, and return an empty location equal to the end + boundary of RHS[0] if the right-hand side is empty. */ + +static YYLTYPE +lloc_default (YYLTYPE const *rhs, int n) +{ + int i; + YYLTYPE loc; + + /* SGI MIPSpro 7.4.1m miscompiles "loc.start = loc.end = rhs[n].end;". + The bug is fixed in 7.4.2m, but play it safe for now. */ + loc.start = rhs[n].end; + loc.end = rhs[n].end; + + /* Ignore empty nonterminals the start of the right-hand side. + Do not bother to ignore them at the end of the right-hand side, + since empty nonterminals have the same end as their predecessors. */ + for (i = 1; i <= n; i++) + if (! equal_boundaries (rhs[i].start, rhs[i].end)) + { + loc.start = rhs[i].start; + break; + } + + return loc; +} + +static +char *strip_braces (char *code) +{ + code[strlen(code) - 1] = 0; + return code + 1; +} + +static +char const * +translate_code (char *code, location loc, bool plain) +{ + code_props plain_code; + if (plain) + code_props_plain_init (&plain_code, code, loc); + else + code_props_symbol_action_init (&plain_code, code, loc); + code_props_translate_code (&plain_code); + gram_scanner_last_string_free (); + return plain_code.code; +} + +static +char const * +translate_code_braceless (char *code, location loc) +{ + return translate_code (strip_braces (code), loc, true); +} static void -yyprint (FILE *file, - int type, const yystype *value) +add_param (param_type type, char *decl, location loc) { - fputc (' ', file); - switch (type) + static char const alphanum[26 + 26 + 1 + 10] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "_" + "0123456789"; + + char const *name_start = NULL; + { + char *p; + /* Stop on last actual character. */ + for (p = decl; p[1]; p++) + if ((p == decl + || ! memchr (alphanum, p[-1], sizeof alphanum)) + && memchr (alphanum, p[0], sizeof alphanum - 10)) + name_start = p; + + /* Strip the surrounding '{' and '}', and any blanks just inside + the braces. */ + --p; + while (c_isspace ((unsigned char) *p)) + --p; + p[1] = '\0'; + ++decl; + while (c_isspace ((unsigned char) *decl)) + ++decl; + } + + if (! name_start) + complain (&loc, complaint, _("missing identifier in parameter declaration")); + else { - case ID: - fprintf (file, " = %s", value->symbol->tag); - break; + char *name = xmemdup0 (name_start, strspn (name_start, alphanum)); + if (type & param_lex) + muscle_pair_list_grow ("lex_param", decl, name); + if (type & param_parse) + muscle_pair_list_grow ("parse_param", decl, name); + free (name); + } - case INT: - fprintf (file, " = %d", value->integer); - break; + gram_scanner_last_string_free (); +} - case STRING: - fprintf (file, " = \"%s\"", value->string); - break; - case TYPE: - fprintf (file, " = <%s>", value->struniq); - break; +static void +version_check (location const *loc, char const *version) +{ + if (strverscmp (version, PACKAGE_VERSION) > 0) + { + complain (loc, complaint, "require bison %s, but have %s", + version, PACKAGE_VERSION); + exit (EX_MISMATCH); + } +} - case BRACED_CODE: - case PROLOGUE: - case EPILOGUE: - fprintf (file, " = {{ %s }}", value->string); - break; +static void +gram_error (location const *loc, char const *msg) +{ + complain (loc, complaint, "%s", msg); +} - default: - fprintf (file, "unknown token type"); - break; +char const * +token_name (int type) +{ + return yytname[YYTRANSLATE (type)]; +} + +static char const * +char_name (char c) +{ + if (c == '\'') + return "'\\''"; + else + { + char buf[4]; + buf[0] = '\''; buf[1] = c; buf[2] = '\''; buf[3] = '\0'; + return quotearg_style (escape_quoting_style, buf); } } +static void -gram_error (location_t *yylloc, const char *msg) +current_lhs (symbol *sym, location loc, named_ref *ref) { - complain_at (*yylloc, "%s", msg); + current_lhs_symbol = sym; + current_lhs_location = loc; + /* In order to simplify memory management, named references for lhs + are always assigned by deep copy into the current symbol_list + node. This is because a single named-ref in the grammar may + result in several uses when the user factors lhs between several + rules using "|". Therefore free the parser's original copy. */ + free (current_lhs_named_ref); + current_lhs_named_ref = ref; }