<http://lists.gnu.org/archive/html/bison-patches/2006-11/msg00039.html>.
* NEWS (2.3a+): Update.
* doc/bison.texinfo (Freeing Discarded Symbols, Bison Symbols):
Update.
* src/parse-gram.y (TYPE_TAG_NONE, generic_symlist_item): Implement.
* src/scan-gram.l (INITIAL): Implement.
* src/symlist.c (symbol_list_default_tagless_new): Update comment.
* src/symlist.h (symbol_list, symbol_list_default_tagless_new): Update
comment.
* tests/actions.at (Default tagless %printer and %destructor,
Default tagged and per-type %printer and %destructor,
Default %printer and %destructor are not for error or $undefined,
Default %printer and %destructor are not for $accept,
Default %printer and %destructor for mid-rule values): Update.
* tests/input.at (Default %printer and %destructor redeclared,
Unused values with default %destructor): Update.
+2006-11-20 Joel E. Denny <jdenny@ces.clemson.edu>
+
+ Rename <!> to <>. Discussed starting at
+ <http://lists.gnu.org/archive/html/bison-patches/2006-11/msg00039.html>.
+ * NEWS (2.3a+): Update.
+ * doc/bison.texinfo (Freeing Discarded Symbols, Bison Symbols):
+ Update.
+ * src/parse-gram.y (TYPE_TAG_NONE, generic_symlist_item): Implement.
+ * src/scan-gram.l (INITIAL): Implement.
+ * src/symlist.c (symbol_list_default_tagless_new): Update comment.
+ * src/symlist.h (symbol_list, symbol_list_default_tagless_new): Update
+ comment.
+ * tests/actions.at (Default tagless %printer and %destructor,
+ Default tagged and per-type %printer and %destructor,
+ Default %printer and %destructor are not for error or $undefined,
+ Default %printer and %destructor are not for $accept,
+ Default %printer and %destructor for mid-rule values): Update.
+ * tests/input.at (Default %printer and %destructor redeclared,
+ Unused values with default %destructor): Update.
+
2006-11-17 Joel E. Denny <jdenny@ces.clemson.edu>
Don't let %prec take a nonterminal.
* doc/bison.texinfo (Freeing Discarded Symbols): Document this and the
previous change today related to mid-rules.
(Bison Symbols): Remove %symbol-default and add <*> and <!>.
- * src/parser-gram.y (PERCENT_SYMBOL_DEFAULT): Remove.
+ * src/parse-gram.y (PERCENT_SYMBOL_DEFAULT): Remove.
(TYPE_TAG_ANY): Add as <*>.
(TYPE_TAG_NONE): Add as <!>.
(generic_symlist_item): Remove RHS for %symbol-default and add RHS's
%destructor/%printer for all grammar symbols for which you have formally
declared semantic type tags.
- 2. Place `<!>' in a %destructor/%printer symbol list to define a default
+ 2. Place `<>' in a %destructor/%printer symbol list to define a default
%destructor/%printer for all grammar symbols without declared semantic
type tags.
Bison no longer supports the `%symbol-default' notation from Bison 2.3a.
- `<*>' and `<!>' combined achieve the same effect with one exception: Bison no
+ `<*>' and `<>' combined achieve the same effect with one exception: Bison no
longer applies any %destructor to a mid-rule value if that mid-rule value is
not actually ever referenced using either $$ or $n in a semantic action.
@cindex freeing discarded symbols
@findex %destructor
@findex <*>
-@findex <!>
+@findex <>
During error recovery (@pxref{Error Recovery}), symbols already pushed
on the stack and tokens coming from the rest of the file are discarded
until the parser falls on its feet. If the parser runs out of memory,
per-symbol @code{%destructor}.
Finally, you can define two different kinds of default @code{%destructor}s.
-You can place each of @code{<*>} and @code{<!>} in the @var{symbols} list of
+You can place each of @code{<*>} and @code{<>} in the @var{symbols} list of
exactly one @code{%destructor} declaration in your grammar file.
The parser will invoke the @var{code} associated with one of these whenever it
discards any user-defined grammar symbol that has no per-symbol and no per-type
The parser uses the @var{code} for @code{<*>} in the case of such a grammar
symbol for which you have formally declared a semantic type tag (@code{%type}
counts as such a declaration, but @code{$<tag>$} does not).
-The parser uses the @var{code} for @code{<!>} in the case of such a grammar
+The parser uses the @var{code} for @code{<>} in the case of such a grammar
symbol that has no declared semantic type tag.
@end deffn
%destructor @{ @} <character>
%destructor @{ free ($$); @} <*>
%destructor @{ free ($$); printf ("%d", @@$.first_line); @} STRING1 string1
-%destructor @{ printf ("Discarding tagless symbol.\n"); @} <!>
+%destructor @{ printf ("Discarding tagless symbol.\n"); @} <>
@end smallexample
@noindent
@var{n} is the RHS symbol position of the mid-rule) in any later action in that
rule.
However, if you do reference either, the Bison-generated parser will invoke the
-@code{<!>} @code{%destructor} whenever it discards the mid-rule symbol.
+@code{<>} @code{%destructor} whenever it discards the mid-rule symbol.
@ignore
@noindent
@xref{Destructor Decl, , Freeing Discarded Symbols}.
@end deffn
-@deffn {Directive} <!>
+@deffn {Directive} <>
Used to define a default tagless @code{%destructor} or default tagless
@code{%printer}.
@xref{Destructor Decl, , Freeing Discarded Symbols}.
"\"%requires\"", "\"%skeleton\"", "\"%start\"", "\"%token-table\"",
"\"%verbose\"", "\"%yacc\"", "\"{...}\"", "\"char\"", "\"epilogue\"",
"\"=\"", "\"identifier\"", "\"identifier:\"", "\"%%\"", "\"|\"",
- "\"%{...%}\"", "\";\"", "\"type\"", "\"<*>\"", "\"<!>\"", "\"%union\"",
+ "\"%{...%}\"", "\";\"", "\"type\"", "\"<*>\"", "\"<>\"", "\"%union\"",
"$accept", "input", "prologue_declarations", "prologue_declaration",
"grammar_declaration", "union_name", "symbol_declaration", "$@1", "$@2",
"precedence_declaration", "precedence_declarator", "type.opt",
%token SEMICOLON ";"
%token TYPE "type"
%token TYPE_TAG_ANY "<*>"
-%token TYPE_TAG_NONE "<!>"
+%token TYPE_TAG_NONE "<>"
%type <character> CHAR
%printer { fputs (char_name ($$), stderr); } CHAR
symbol { $$ = symbol_list_sym_new ($1, @1); }
| TYPE { $$ = symbol_list_type_new ($1, @1); }
| "<*>" { $$ = symbol_list_default_tagged_new (@1); }
-| "<!>" { $$ = symbol_list_default_tagless_new (@1); }
+| "<>" { $$ = symbol_list_default_tagless_new (@1); }
;
/* One token definition. */
"|" return PIPE;
";" return SEMICOLON;
"<*>" return TYPE_TAG_ANY;
- "<!>" return TYPE_TAG_NONE;
+ "<>" return TYPE_TAG_NONE;
{id} {
val->uniqstr = uniqstr_new (yytext);
}
-/*----------------------------------------.
-| Create a list containing a <!> at LOC. |
-`----------------------------------------*/
+/*---------------------------------------.
+| Create a list containing a <> at LOC. |
+`---------------------------------------*/
symbol_list *
symbol_list_default_tagless_new (location loc)
{
/**
* Whether this node contains a symbol, a semantic type, a \c <*>, or a
- * \c <!>.
+ * \c <>.
*/
enum {
SYMLIST_SYMBOL, SYMLIST_TYPE,
/** Create a list containing a \c <*> at \c loc. */
symbol_list *symbol_list_default_tagged_new (location loc);
-/** Create a list containing a \c <!> at \c loc. */
+/** Create a list containing a \c <> at \c loc. */
symbol_list *symbol_list_default_tagless_new (location loc);
/** Print this list.
} <*>
%printer {
- fprintf (yyoutput, "<!> printer for '%c' @ %d", $$, @$.first_column);
-} <!>
+ fprintf (yyoutput, "<> printer for '%c' @ %d", $$, @$.first_column);
+} <>
%destructor {
- fprintf (stdout, "<!> destructor for '%c' @ %d.\n", $$, @$.first_column);
-} <!>
+ fprintf (stdout, "<> destructor for '%c' @ %d.\n", $$, @$.first_column);
+} <>
%printer {
fprintf (yyoutput, "'b'/'c' printer for '%c' @ %d", $$, @$.first_column);
AT_CHECK([bison -o input.c input.y])
AT_COMPILE([input])
AT_PARSER_CHECK([./input], 1,
-[[<!> destructor for 'd' @ 4.
+[[<> destructor for 'd' @ 4.
'b'/'c' destructor for 'c' @ 3.
'b'/'c' destructor for 'b' @ 2.
-<!> destructor for 'a' @ 1.
+<> destructor for 'a' @ 1.
]],
[[Starting parse
Entering state 0
-Reading a token: Next token is token 'a' (1.1-1.1: <!> printer for 'a' @ 1)
-Shifting token 'a' (1.1-1.1: <!> printer for 'a' @ 1)
+Reading a token: Next token is token 'a' (1.1-1.1: <> printer for 'a' @ 1)
+Shifting token 'a' (1.1-1.1: <> printer for 'a' @ 1)
Entering state 1
Reading a token: Next token is token 'b' (1.2-1.2: 'b'/'c' printer for 'b' @ 2)
Shifting token 'b' (1.2-1.2: 'b'/'c' printer for 'b' @ 2)
Reading a token: Next token is token 'c' (1.3-1.3: 'b'/'c' printer for 'c' @ 3)
Shifting token 'c' (1.3-1.3: 'b'/'c' printer for 'c' @ 3)
Entering state 5
-Reading a token: Next token is token 'd' (1.4-1.4: <!> printer for 'd' @ 4)
-Shifting token 'd' (1.4-1.4: <!> printer for 'd' @ 4)
+Reading a token: Next token is token 'd' (1.4-1.4: <> printer for 'd' @ 4)
+Shifting token 'd' (1.4-1.4: <> printer for 'd' @ 4)
Entering state 6
Reading a token: Now at end of input.
syntax error, unexpected $end, expecting 'e'
-Error: popping token 'd' (1.4-1.4: <!> printer for 'd' @ 4)
+Error: popping token 'd' (1.4-1.4: <> printer for 'd' @ 4)
Stack now 0 1 3 5
Error: popping token 'c' (1.3-1.3: 'b'/'c' printer for 'c' @ 3)
Stack now 0 1 3
Error: popping token 'b' (1.2-1.2: 'b'/'c' printer for 'b' @ 2)
Stack now 0 1
-Error: popping token 'a' (1.1-1.1: <!> printer for 'a' @ 1)
+Error: popping token 'a' (1.1-1.1: <> printer for 'a' @ 1)
Stack now 0
Cleanup: discarding lookahead token $end (1.5-1.5: )
Stack now 0
%}
%printer {
- fprintf (yyoutput, "<!> printer should not be called.\n");
-} <!>
+ fprintf (yyoutput, "<> printer should not be called.\n");
+} <>
%union { int field0; int field1; int field2; }
%type <field0> start 'a' 'g'
%destructor { fprintf (stdout, "'d' destructor.\n"); } 'd'
%destructor {
- fprintf (yyoutput, "<!> destructor should not be called.\n");
-} <!>
+ fprintf (yyoutput, "<> destructor should not be called.\n");
+} <>
%%
# -----------------------------------------------------------------------------
m4_define([_AT_CHECK_DEFAULT_PRINTER_AND_DESTRUCTOR_FOR_END_TOKEN],
[m4_if($1, 0,
- [m4_pushdef([kind], [!]) m4_pushdef([not_kind], [*])],
- [m4_pushdef([kind], [*]) m4_pushdef([not_kind], [!])])
+ [m4_pushdef([kind], []) m4_pushdef([not_kind], [*])],
+ [m4_pushdef([kind], [*]) m4_pushdef([not_kind], [])])
AT_DATA_GRAMMAR([[input]]$1[[.y]],
[[%error-verbose
%printer {
fprintf (yyoutput, "'%c'", $$);
-} <!> <*>
+} <> <*>
%destructor {
fprintf (stderr, "DESTROY '%c'\n", $$);
-} <!> <*>
+} <> <*>
%%
%printer {
char chr = $$;
fprintf (yyoutput, "'%c'", chr);
-} <!> <*>
+} <> <*>
%destructor {
char chr = $$;
fprintf (stderr, "DESTROY '%c'\n", chr);
-} <!> <*>
+} <> <*>
%union { char chr; }
%type <chr> start
# define YY_LOCATION_PRINT(File, Loc)
%}
-%printer { fprintf (yyoutput, "%d", @$); } <!>
-%destructor { fprintf (stderr, "DESTROY %d\n", @$); } <!>
+%printer { fprintf (yyoutput, "%d", @$); } <>
+%destructor { fprintf (stderr, "DESTROY %d\n", @$); } <>
%printer { fprintf (yyoutput, "<*> printer should not be called"); } <*>
%destructor { fprintf (yyoutput, "<*> destructor should not be called"); } <*>
%destructor { destroy ($$); } <*>
%printer { destroy ($$); } <*>
-%destructor { destroy ($$); } <!> <!>
-%printer { destroy ($$); } <!> <!>
+%destructor { destroy ($$); } <> <>
+%printer { destroy ($$); } <> <>
-%destructor { destroy ($$); } <!>
-%printer { destroy ($$); } <!>
+%destructor { destroy ($$); } <>
+%printer { destroy ($$); } <>
%%
%destructor { destroy ($$); } <*>;
%printer { destroy ($$); } <*>;
-%destructor { destroy ($$); } <!>;
-%printer { destroy ($$); } <!>;
+%destructor { destroy ($$); } <>;
+%printer { destroy ($$); } <>;
]])
AT_CHECK([bison input.y], [1], [],
AT_SETUP([Unused values with default %destructor])
AT_DATA([[input.y]],
-[[%destructor { destroy ($$); } <!>
+[[%destructor { destroy ($$); } <>
%type <tag> tagged
%%