X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/575619af5e1f61a5f78fb3910bee424ead5fe5a6..9402b623533a83d8aade70988622ad7e5f063117:/src/parse-gram.y?ds=sidebyside diff --git a/src/parse-gram.y b/src/parse-gram.y index f79b0e92..9a266251 100644 --- a/src/parse-gram.y +++ b/src/parse-gram.y @@ -1,6 +1,6 @@ -%{/* Bison Grammar Parser -*- C -*- +/* Bison Grammar Parser -*- C -*- - Copyright (C) 2002-2011 Free Software Foundation, Inc. + Copyright (C) 2002-2013 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -17,64 +17,87 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . */ -#include -#include "system.h" - -#include "complain.h" -#include "conflicts.h" -#include "files.h" -#include "getargs.h" -#include "gram.h" -#include "muscle-tab.h" -#include "named-ref.h" -#include "quotearg.h" -#include "reader.h" -#include "symlist.h" -#include "scan-gram.h" -#include "scan-code.h" - -#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 (File, Loc) - -static void version_check (location const *loc, char const *version); - -/* Request detailed syntax error messages, and pass them to GRAM_ERROR. - FIXME: depends on the undocumented availability of YYLLOC. */ -#undef yyerror -#define yyerror(Msg) \ - gram_error (&yylloc, Msg) -static void gram_error (location const *, char const *); - -static char const *char_name (char); -%} +%code requires +{ + #include "symlist.h" + #include "symtab.h" +} %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; + 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 } -%debug -%verbose -%defines -%locations -%pure-parser -%define parse.error "verbose" +%define api.prefix {gram_} +%define api.pure full +%define locations +%define parse.error verbose %define parse.lac full -%name-prefix="gram_" +%define parse.trace +%defines %expect 0 +%verbose %initial-action { @@ -84,23 +107,9 @@ static char const *char_name (char); boundary_set (&@$.end, current_file, 1, 1); } -%union -{ - assoc assoc; - char *code; - char const *chars; - int integer; - named_ref *named_ref; - symbol *symbol; - symbol_list *list; - uniqstr uniqstr; - unsigned char character; -}; - /* 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" @@ -165,34 +174,39 @@ static char const *char_name (char); %token TAG_ANY "<*>" %token TAG_NONE "<>" +%union {unsigned char character;} %type CHAR -%printer { fputs (char_name ($$), stderr); } CHAR - -/* braceless is not to be used for rule or symbol actions, as it - calls code_props_plain_init. */ -%type STRING "%{...%}" EPILOGUE braceless content.opt -%type "{...}" "%?{...}" -%printer { fputs (quotearg_style (c_quoting_style, $$), stderr); } - STRING -%printer { fprintf (stderr, "{\n%s\n}", $$); } - braceless content.opt "{...}" "%{...%}" EPILOGUE - -%type BRACKETED_ID ID ID_COLON PERCENT_FLAG TAG variable -%printer { fputs ($$, stderr); } -%printer { fprintf (stderr, "[%s]", $$); } BRACKETED_ID -%printer { fprintf (stderr, "%s:", $$); } ID_COLON -%printer { fprintf (stderr, "%%%s", $$); } PERCENT_FLAG -%printer { fprintf (stderr, "<%s>", $$); } TAG - -%type INT -%printer { fprintf (stderr, "%d", $$); } - +%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 (stderr, "%s", $$->tag); } -%printer { fprintf (stderr, "%s:", $$->tag); } id_colon +%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 + +%union {named_ref *named_ref;} %type named_ref.opt /*---------. @@ -200,8 +214,6 @@ static char const *char_name (char); `---------*/ %code requires { -# ifndef PARAM_TYPE -# define PARAM_TYPE typedef enum { param_none = 0, @@ -209,7 +221,6 @@ static char const *char_name (char); param_parse = 1 << 1, param_both = param_lex | param_parse } param_type; -# endif }; %code { @@ -222,20 +233,17 @@ static char const *char_name (char); static void add_param (param_type type, char *decl, location loc); static param_type current_param = param_none; }; -%union -{ - param_type param; -} +%union {param_type param;} %token PERCENT_PARAM "%param"; %printer { switch ($$) { #define CASE(In, Out) \ - case param_ ## In: fputs ("%" #Out, stderr); break - CASE(lex, lex-param); - CASE(parse, parse-param); - CASE(both, param); + 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; } @@ -252,12 +260,12 @@ input: ; - /*------------------------------------. - | Declarations: before the first %%. | - `------------------------------------*/ + /*------------------------------------. + | Declarations: before the first %%. | + `------------------------------------*/ prologue_declarations: - /* Nothing */ + %empty | prologue_declarations prologue_declaration ; @@ -265,21 +273,17 @@ prologue_declaration: grammar_declaration | "%{...%}" { - code_props plain_code; - code_props_plain_init (&plain_code, $1, @1); - code_props_translate_code (&plain_code); - gram_scanner_last_string_free (); muscle_code_grow (union_seen ? "post_prologue" : "pre_prologue", - plain_code.code, @1); + translate_code ($1, @1, true), @1); code_scanner_last_string_free (); } | "%" { muscle_percent_define_ensure ($1, @1, true); } -| "%define" variable content.opt +| "%define" variable value { - muscle_percent_define_insert ($2, @2, $3, + muscle_percent_define_insert ($2, @2, $3.kind, $3.chars, MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE); } | "%defines" { defines_flag = true; } @@ -290,13 +294,13 @@ prologue_declaration: } | "%error-verbose" { - muscle_percent_define_insert ("parse.error", @1, "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; } +| "%expect-rr" INT { expected_rr_conflicts = $2; } | "%file-prefix" STRING { spec_file_prefix = $2; } -| "%file-prefix" "=" STRING { spec_file_prefix = $3; } /* deprecated */ | "%glr-parser" { nondeterministic_parser = true; @@ -304,20 +308,14 @@ prologue_declaration: } | "%initial-action" "{...}" { - code_props action; - code_props_symbol_action_init (&action, $2, @2); - code_props_translate_code (&action); - gram_scanner_last_string_free (); - muscle_code_grow ("initial_action", action.code, @2); + muscle_code_grow ("initial_action", translate_code ($2, @2, false), @2); code_scanner_last_string_free (); } -| "%language" STRING { language_argmatch ($2, grammar_prio, @1); } +| "%language" STRING { language_argmatch ($2, grammar_prio, @1); } | "%name-prefix" STRING { spec_name_prefix = $2; } -| "%name-prefix" "=" STRING { spec_name_prefix = $3; } /* deprecated */ | "%no-lines" { no_lines_flag = true; } -| "%nondeterministic-parser" { nondeterministic_parser = true; } +| "%nondeterministic-parser" { nondeterministic_parser = true; } | "%output" STRING { spec_outfile = $2; } -| "%output" "=" STRING { spec_outfile = $3; } /* deprecated */ | "%param" { current_param = $1; } params { current_param = param_none; } | "%require" STRING { version_check (&@2, $2); } | "%skeleton" STRING @@ -335,7 +333,7 @@ prologue_declaration: xmalloc (dir_length + 1 + strlen (skeleton_user) + 1); if (dir_length > 0) { - strncpy (skeleton_build, current_file, dir_length); + memcpy (skeleton_build, current_file, dir_length); skeleton_build[dir_length++] = '/'; } strcpy (skeleton_build + dir_length, skeleton_user); @@ -367,19 +365,17 @@ grammar_declaration: { grammar_start_symbol_set ($2, @2); } -| "%destructor" "{...}" generic_symlist - { - symbol_list *list; - for (list = $3; list; list = list->next) - symbol_list_destructor_set (list, $2, @2); - symbol_list_free ($3); - } -| "%printer" "{...}" generic_symlist +| code_props_type "{...}" generic_symlist { - symbol_list *list; - for (list = $3; list; list = list->next) - symbol_list_printer_set (list, $2, @2); - symbol_list_free ($3); + 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" { @@ -389,20 +385,28 @@ grammar_declaration: { default_prec = false; } -| "%code" braceless +| "%code" "{...}" { /* Do not invoke muscle_percent_code_grow here since it invokes muscle_user_name_list_grow. */ - muscle_code_grow ("percent_code()", $2, @2); + muscle_code_grow ("percent_code()", + translate_code_braceless ($2, @2), @2); code_scanner_last_string_free (); } -| "%code" ID braceless +| "%code" ID "{...}" { - muscle_percent_code_grow ($2, @2, $3, @3); + 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. | @@ -411,15 +415,15 @@ grammar_declaration: %token PERCENT_UNION "%union"; union_name: - /* Nothing. */ {} -| ID { muscle_code_grow ("union_name", $1, @1); } + %empty {} +| ID { muscle_code_grow ("union_name", $1, @1); } ; grammar_declaration: - "%union" union_name braceless + "%union" union_name "{...}" { union_seen = true; - muscle_code_grow ("stype", $3, @3); + muscle_code_grow ("union_members", translate_code_braceless ($3, @3), @3); code_scanner_last_string_free (); } ; @@ -443,7 +447,7 @@ symbol_declaration: symbol_list *list; tag_seen = true; for (list = $3; list; list = list->next) - symbol_type_set (list->content.sym, $2, @2); + symbol_type_set (list->content.sym, $2, @2); symbol_list_free ($3); } ; @@ -454,10 +458,10 @@ precedence_declaration: symbol_list *list; ++current_prec; for (list = $3; list; list = list->next) - { - symbol_type_set (list->content.sym, current_type, @2); - symbol_precedence_set (list->content.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; } @@ -471,8 +475,8 @@ precedence_declarator: ; tag.opt: - /* Nothing. */ { current_type = NULL; } -| TAG { current_type = $1; tag_seen = true; } + %empty { current_type = NULL; } +| TAG { current_type = $1; tag_seen = true; } ; /* Just like symbols.1 but accept INT for the sake of POSIX. */ @@ -480,46 +484,59 @@ symbols.prec: symbol.prec { $$ = symbol_list_sym_new ($1, @1); } | symbols.prec symbol.prec - { $$ = symbol_list_prepend ($1, symbol_list_sym_new ($2, @2)); } + { $$ = symbol_list_append ($1, symbol_list_sym_new ($2, @2)); } ; symbol.prec: - symbol { $$ = $1; } - | symbol INT { $$ = $1; symbol_user_token_number_set ($1, $2, @2); } - ; + 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_sym_new ($1, @1); } | symbols.1 symbol - { $$ = symbol_list_prepend ($1, symbol_list_sym_new ($2, @2)); } + { $$ = symbol_list_append ($1, symbol_list_sym_new ($2, @2)); } ; generic_symlist: generic_symlist_item { $$ = $1; } -| generic_symlist generic_symlist_item { $$ = symbol_list_prepend ($1, $2); } +| 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); } -| "<*>" { $$ = symbol_list_default_tagged_new (@1); } -| "<>" { $$ = symbol_list_default_tagless_new (@1); } +| tag { $$ = symbol_list_type_new ($1, @1); } +; + +tag: + TAG +| "<*>" { $$ = uniqstr_new ("*"); } +| "<>" { $$ = uniqstr_new (""); } ; /* One token definition. */ symbol_def: TAG - { - current_type = $1; - tag_seen = true; - } + { + current_type = $1; + tag_seen = true; + } | id - { - symbol_class_set ($1, current_class, @1, true); - symbol_type_set ($1, current_type, @1); - } + { + 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); @@ -548,9 +565,9 @@ symbol_defs.1: ; - /*------------------------------------------. - | The grammar section: between the two %%. | - `------------------------------------------*/ + /*------------------------------------------. + | The grammar section: between the two %%. | + `------------------------------------------*/ grammar: rules_or_grammar_declaration @@ -569,8 +586,11 @@ rules_or_grammar_declaration: ; rules: - id_colon named_ref.opt { current_lhs = $1; current_lhs_location = @1; - current_lhs_named_ref = $2; } 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: @@ -579,16 +599,19 @@ rhses.1: | rhses.1 ";" ; +%token PERCENT_EMPTY "%empty"; rhs: - /* Nothing. */ - { grammar_current_rule_begin (current_lhs, current_lhs_location, - current_lhs_named_ref); } + %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 "%?{...}" +| 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 @@ -598,44 +621,47 @@ rhs: ; named_ref.opt: - /* Nothing. */ { $$ = 0; } -| - BRACKETED_ID { $$ = named_ref_new($1, @1); } + %empty { $$ = 0; } +| BRACKETED_ID { $$ = named_ref_new($1, @1); } ; -/*---------------------------. -| variable and content.opt. | -`---------------------------*/ +/*---------------------. +| variable and value. | +`---------------------*/ /* The STRING form of variable is deprecated and is not M4-friendly. - For example, M4 fails for `%define "[" "value"'. */ + For example, M4 fails for '%define "[" "value"'. */ variable: ID | STRING { $$ = uniqstr_new ($1); } ; /* Some content or empty by default. */ -content.opt: - /* Nothing. */ { $$ = ""; } -| ID { $$ = $1; } -| STRING -; - - -/*------------. -| braceless. | -`------------*/ - -braceless: - "{...}" +%code requires {#include "muscle-tab.h"}; +%union +{ + struct + { + char const *chars; + muscle_kind kind; + } value; +}; +%type value; +%printer +{ + switch ($$.kind) { - code_props plain_code; - $1[strlen ($1) - 1] = '\n'; - code_props_plain_init (&plain_code, $1+1, @1); - code_props_translate_code (&plain_code); - gram_scanner_last_string_free (); - $$ = plain_code.code; + 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 = strip_braces ($1); } ; @@ -677,21 +703,16 @@ string_as_id: ; epilogue.opt: - /* Nothing. */ + %empty | "%%" EPILOGUE { - code_props plain_code; - code_props_plain_init (&plain_code, $2, @2); - code_props_translate_code (&plain_code); - gram_scanner_last_string_free (); - muscle_code_grow ("epilogue", plain_code.code, @2); + muscle_code_grow ("epilogue", translate_code ($2, @2, true), @2); code_scanner_last_string_free (); } ; %% - /* 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 @@ -708,19 +729,46 @@ lloc_default (YYLTYPE const *rhs, int n) loc.start = rhs[n].end; loc.end = rhs[n].end; - /* Ignore empty nonterminals the start of the the right-hand side. + /* 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; + 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 add_param (param_type type, char *decl, location loc) @@ -743,28 +791,20 @@ add_param (param_type type, char *decl, location loc) /* Strip the surrounding '{' and '}', and any blanks just inside the braces. */ - while (*--p == ' ' || *p == '\t') - continue; + --p; + while (c_isspace ((unsigned char) *p)) + --p; p[1] = '\0'; - while (*++decl == ' ' || *decl == '\t') - continue; + ++decl; + while (c_isspace ((unsigned char) *decl)) + ++decl; } if (! name_start) - complain_at (loc, _("missing identifier in parameter declaration")); + complain (&loc, complaint, _("missing identifier in parameter declaration")); else { - char *name; - size_t name_len; - - for (name_len = 1; - memchr (alphanum, name_start[name_len], sizeof alphanum); - name_len++) - continue; - - name = xmalloc (name_len + 1); - memcpy (name, name_start, name_len); - name[name_len] = '\0'; + 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) @@ -781,16 +821,16 @@ version_check (location const *loc, char const *version) { if (strverscmp (version, PACKAGE_VERSION) > 0) { - complain_at (*loc, "require bison %s, but have %s", - version, PACKAGE_VERSION); - exit (63); + complain (loc, complaint, "require bison %s, but have %s", + version, PACKAGE_VERSION); + exit (EX_MISMATCH); } } static void gram_error (location const *loc, char const *msg) { - complain_at (*loc, "%s", msg); + complain (loc, complaint, "%s", msg); } char const * @@ -811,3 +851,18 @@ char_name (char c) return quotearg_style (escape_quoting_style, buf); } } + +static +void +current_lhs (symbol *sym, location loc, named_ref *ref) +{ + 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; +}