Outline of a Bison Grammar
* Prologue:: Syntax and usage of the prologue.
+* Prologue Alternatives:: Syntax and usage of alternatives to the prologue.
* Bison Declarations:: Syntax and usage of the Bison declarations section.
* Grammar Rules:: Syntax and usage of the grammar rules section.
* Epilogue:: Syntax and usage of the epilogue.
@menu
* Prologue:: Syntax and usage of the prologue.
+* Prologue Alternatives:: Syntax and usage of alternatives to the prologue.
* Bison Declarations:: Syntax and usage of the Bison declarations section.
* Grammar Rules:: Syntax and usage of the grammar rules section.
* Epilogue:: Syntax and usage of the epilogue.
don't need any C declarations, you may omit the @samp{%@{} and
@samp{%@}} delimiters that bracket this section.
-The @var{Prologue} section is terminated by the the first occurrence
+The @var{Prologue} section is terminated by the first occurrence
of @samp{%@}} that is outside a comment, a string literal, or a
character constant.
@smallexample
%@{
+ #define _GNU_SOURCE
#include <stdio.h>
#include "ptypes.h"
%@}
@dots{}
@end smallexample
-@findex %before-header
-@findex %start-header
-@findex %after-header
-If you've instructed Bison to generate a header file (@pxref{Table of Symbols,
-,%defines}), you probably want @code{#include "ptypes.h"} to appear
-in that header file as well.
-In that case, use @code{%before-header}, @code{%start-header}, and
-@code{%after-header} instead of @var{Prologue} sections
-(@pxref{Table of Symbols, ,%start-header}):
+When in doubt, it is usually safer to put prologue code before all
+Bison declarations, rather than after. For example, any definitions
+of feature test macros like @code{_GNU_SOURCE} or
+@code{_POSIX_C_SOURCE} should appear before all Bison declarations, as
+feature test macros can affect the behavior of Bison-generated
+@code{#include} directives.
+
+@node Prologue Alternatives
+@subsection Prologue Alternatives
+@cindex Prologue Alternatives
+
+@findex %code
+@findex %requires
+@findex %provides
+@findex %code-top
+The functionality of @var{Prologue} sections can often be subtle and
+inflexible.
+As an alternative, Bison provides a set of more explicit directives:
+@code{%code-top}, @code{%requires}, @code{%provides}, and @code{%code}.
+@xref{Table of Symbols}.
+
+Look again at the example of the previous section:
@smallexample
-%before-header @{
+%@{
+ #define _GNU_SOURCE
#include <stdio.h>
+ #include "ptypes.h"
+%@}
+
+%union @{
+ long int n;
+ tree t; /* @r{@code{tree} is defined in @file{ptypes.h}.} */
@}
-%start-header @{
+%@{
+ static void print_token_value (FILE *, int, YYSTYPE);
+ #define YYPRINT(F, N, L) print_token_value (F, N, L)
+%@}
+
+@dots{}
+@end smallexample
+
+@noindent
+Notice that there are two @var{Prologue} sections here, but there's a subtle
+distinction between their functionality.
+For example, if you decide to override Bison's default definition for
+@code{YYLTYPE}, in which @var{Prologue} section should you write your new
+definition?
+You should write it in the first since Bison will insert that code into the
+parser code file @emph{before} the default @code{YYLTYPE} definition.
+In which @var{Prologue} section should you prototype an internal function,
+@code{trace_token}, that accepts @code{YYLTYPE} and @code{yytokentype} as
+arguments?
+You should prototype it in the second since Bison will insert that code
+@emph{after} the @code{YYLTYPE} and @code{yytokentype} definitions.
+
+This distinction in functionality between the two @var{Prologue} sections is
+established by the appearance of the @code{%union} between them.
+This behavior raises several questions.
+First, why should the position of a @code{%union} affect definitions related to
+@code{YYLTYPE} and @code{yytokentype}?
+Second, what if there is no @code{%union}?
+In that case, the second kind of @var{Prologue} section is not available.
+This behavior is not intuitive.
+
+To avoid this subtle @code{%union} dependency, rewrite the example using
+@code{%code-top} and @code{%code}.
+Let's go ahead and add the new @code{YYLTYPE} definition and the
+@code{trace_token} prototype at the same time:
+
+@smallexample
+%code-top @{
+ #define _GNU_SOURCE
+ #include <stdio.h>
+ /* The following code really belongs in a %requires; see below. */
#include "ptypes.h"
+ #define YYLTYPE YYLTYPE
+ typedef struct YYLTYPE
+ @{
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+ char *filename;
+ @} YYLTYPE;
@}
+
%union @{
long int n;
tree t; /* @r{@code{tree} is defined in @file{ptypes.h}.} */
@}
-%after-header @{
+%code @{
+ static void print_token_value (FILE *, int, YYSTYPE);
+ #define YYPRINT(F, N, L) print_token_value (F, N, L)
+ static void trace_token (enum yytokentype token, YYLTYPE loc);
+@}
+
+@dots{}
+@end smallexample
+
+@noindent
+In this way, @code{%code-top} and @code{%code} achieve the same functionality
+as the two kinds of @var{Prologue} sections, but it's always explicit which
+kind you intend.
+Moreover, both kinds are always available even in the absence of @code{%union}.
+
+The first @var{Prologue} section above now logically contains two parts.
+The first two lines need to appear in the parser code file.
+The fourth line is required by @code{YYSTYPE} and thus also needs to appear in
+the parser code file.
+However, if you've instructed Bison to generate a parser header file
+(@pxref{Table of Symbols, ,%defines}), you probably want the third line to
+appear before the @code{YYSTYPE} definition in that header file as well.
+Also, the @code{YYLTYPE} definition should appear in the parser header file to
+override the default @code{YYLTYPE} definition there.
+
+In other words, in the first @var{Prologue} section, all but the first two
+lines are dependency code for externally exposed definitions (@code{YYSTYPE}
+and @code{YYLTYPE}) required by Bison.
+Thus, they belong in one or more @code{%requires}:
+
+@smallexample
+%code-top @{
+ #define _GNU_SOURCE
+ #include <stdio.h>
+@}
+
+%requires @{
+ #include "ptypes.h"
+@}
+%union @{
+ long int n;
+ tree t; /* @r{@code{tree} is defined in @file{ptypes.h}.} */
+@}
+
+%requires @{
+ #define YYLTYPE YYLTYPE
+ typedef struct YYLTYPE
+ @{
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+ char *filename;
+ @} YYLTYPE;
+@}
+
+%code @{
+ static void print_token_value (FILE *, int, YYSTYPE);
+ #define YYPRINT(F, N, L) print_token_value (F, N, L)
+ static void trace_token (enum yytokentype token, YYLTYPE loc);
+@}
+
+@dots{}
+@end smallexample
+
+@noindent
+Now Bison will insert @code{#include "ptypes.h"} and the new @code{YYLTYPE}
+definition before the Bison-generated @code{YYSTYPE} and @code{YYLTYPE}
+definitions in both the parser code file and the parser header file.
+(By the same reasoning, @code{%requires} would also be the appropriate place to
+write your own definition for @code{YYSTYPE}.)
+
+At some point while developing your parser, you might decide to provide
+@code{trace_token} to modules that are external to your parser.
+Thus, you might wish for Bison to insert the prototype into both the parser
+header file and the parser code file.
+Since this function is not a dependency of any Bison-required definition (such
+as @code{YYSTYPE}), it doesn't make sense to move its prototype to a
+@code{%requires}.
+More importantly, since it depends upon @code{YYLTYPE} and @code{yytokentype},
+@code{%requires} is not sufficient.
+Instead, move its prototype from the @code{%code} to a @code{%provides}:
+
+@smallexample
+%code-top @{
+ #define _GNU_SOURCE
+ #include <stdio.h>
+@}
+
+%requires @{
+ #include "ptypes.h"
+@}
+%union @{
+ long int n;
+ tree t; /* @r{@code{tree} is defined in @file{ptypes.h}.} */
+@}
+
+%requires @{
+ #define YYLTYPE YYLTYPE
+ typedef struct YYLTYPE
+ @{
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+ char *filename;
+ @} YYLTYPE;
+@}
+
+%provides @{
+ void trace_token (enum yytokentype token, YYLTYPE loc);
+@}
+
+%code @{
static void print_token_value (FILE *, int, YYSTYPE);
#define YYPRINT(F, N, L) print_token_value (F, N, L)
@}
@dots{}
@end smallexample
+@noindent
+Bison will insert the @code{trace_token} prototype into both the parser header
+file and the parser code file after the definitions for @code{yytokentype},
+@code{YYLTYPE}, and @code{YYSTYPE}.
+
+The above examples are careful to write directives in an order that reflects
+the layout of the generated parser code and header files:
+@code{%code-top}, @code{%requires}, @code{%provides}, and then @code{%code}.
+While your grammar files will generally be easier to read if you also follow
+this order, Bison does not require it.
+Instead, Bison lets you choose an organization that makes sense to you.
+
+Any of these directives may be declared multiple times in the grammar file.
+In that case, Bison concatenates the contained code in declaration order.
+This is the only way in which the position of one of these directives within
+the grammar file affects its functionality.
+
+The result of the previous two properties is greater flexibility in how you may
+organize your grammar file.
+For example, you may organize semantic-type-related directives by semantic
+type:
+
+@smallexample
+%requires @{ #include "type1.h" @}
+%union @{ type1 field1; @}
+%destructor @{ type1_free ($$); @} <field1>
+%printer @{ type1_print ($$); @} <field1>
+
+%requires @{ #include "type2.h" @}
+%union @{ type2 field2; @}
+%destructor @{ type2_free ($$); @} <field2>
+%printer @{ type2_print ($$); @} <field2>
+@end smallexample
+
+@noindent
+You could even place each of the above directive groups in the rules section of
+the grammar file next to the set of rules that uses the associated semantic
+type.
+And you don't have to worry that some directive (like a @code{%union}) in the
+definitions section is going to adversely affect their functionality in some
+counter-intuitive manner just because it comes first.
+Such an organization is not possible using @var{Prologue} sections.
+
@node Bison Declarations
@subsection The Bison Declarations Section
@cindex Bison declarations (introduction)
@acronym{RPN} and infix calculator examples (@pxref{RPN Calc, ,Reverse Polish
Notation Calculator}).
-Bison's default is to use type @code{int} for all semantic values. To
+Bison normally uses the type @code{int} for semantic values if your
+program uses the same data type for all language constructs. To
specify some other type, define @code{YYSTYPE} as a macro, like this:
@example
@itemize @bullet
@item
-Specify the entire collection of possible data types, with the
+Specify the entire collection of possible data types, either by using the
@code{%union} Bison declaration (@pxref{Union Decl, ,The Collection of
-Value Types}).
+Value Types}), or by using a @code{typedef} or a @code{#define} to
+define @code{YYSTYPE} to be a union type whose member names are
+the type tags.
@item
Choose one of those types for each symbol (terminal or nonterminal) for
restoring it.
Thus, @code{$<context>5} needs a destructor (@pxref{Destructor Decl, , Freeing
Discarded Symbols}).
-However, Bison currently provides no means to declare a destructor for a
-mid-rule action's semantic value.
+However, Bison currently provides no means to declare a destructor specific to
+a particular mid-rule action's semantic value.
One solution is to bury the mid-rule action inside a nonterminal symbol and to
declare a destructor for that symbol:
You can specify the type of locations by defining a macro called
@code{YYLTYPE}, just as you can specify the semantic value type by
-defining @code{YYSTYPE} (@pxref{Value Type}).
+defining a @code{YYSTYPE} macro (@pxref{Value Type}).
When @code{YYLTYPE} is not defined, Bison uses a default structure type with
four members:
Note that, unlike making a @code{union} declaration in C, you need not write
a semicolon after the closing brace.
+Instead of @code{%union}, you can define and use your own union type
+@code{YYSTYPE} if your grammar contains at least one
+@samp{<@var{type}>} tag. For example, you can put the following into
+a header file @file{parser.h}:
+
+@example
+@group
+union YYSTYPE @{
+ double val;
+ symrec *tptr;
+@};
+typedef union YYSTYPE YYSTYPE;
+@end group
+@end example
+
+@noindent
+and then your grammar can use the following
+instead of @code{%union}:
+
+@example
+@group
+%@{
+#include "parser.h"
+%@}
+%type <val> expr
+%token <tptr> ID
+@end group
+@end example
+
@node Type Decl
@subsection Nonterminal Symbols
@cindex declaring value types, nonterminals
@subsection Freeing Discarded Symbols
@cindex freeing discarded symbols
@findex %destructor
+@findex %symbol-default
During error recovery (@pxref{Error Recovery}), symbols already pushed
on the stack and tokens coming from the rest of the file are discarded
Invoke the braced @var{code} whenever the parser discards one of the
@var{symbols}.
Within @var{code}, @code{$$} designates the semantic value associated
-with the discarded symbol. The additional parser parameters are also
-available (@pxref{Parser Function, , The Parser Function
-@code{yyparse}}).
+with the discarded symbol, and @code{@@$} designates its location.
+The additional parser parameters are also available (@pxref{Parser Function, ,
+The Parser Function @code{yyparse}}).
+
+When a symbol is listed among @var{symbols}, its @code{%destructor} is called a
+per-symbol @code{%destructor}.
+You may also define a per-type @code{%destructor} by listing a semantic type
+among @var{symbols}.
+In that case, the parser will invoke this @var{code} whenever it discards any
+grammar symbol that has that semantic type unless that symbol has its own
+per-symbol @code{%destructor}.
+
+Finally, you may define a default @code{%destructor} by placing
+@code{%symbol-default} in the @var{symbols} list of exactly one
+@code{%destructor} declaration in your grammar file.
+In that case, the parser will invoke the associated @var{code} whenever it
+discards any user-defined grammar symbol for which there is no per-type or
+per-symbol @code{%destructor}.
@end deffn
+@noindent
For instance:
@smallexample
-%union
-@{
- char *string;
-@}
-%token <string> STRING
-%type <string> string
-%destructor @{ free ($$); @} STRING string
+%union @{ char *string; @}
+%token <string> STRING1
+%token <string> STRING2
+%type <string> string1
+%type <string> string2
+%union @{ char character; @}
+%token <character> CHR
+%type <character> chr
+%destructor @{ free ($$); @} %symbol-default
+%destructor @{ free ($$); printf ("%d", @@$.first_line); @} STRING1 string1
+%destructor @{ @} <character>
+@end smallexample
+
+@noindent
+guarantees that, when the parser discards any user-defined symbol that has a
+semantic type tag other than @code{<character>}, it passes its semantic value
+to @code{free}.
+However, when the parser discards a @code{STRING1} or a @code{string1}, it also
+prints its line number to @code{stdout}.
+It performs only the second @code{%destructor} in this case, so it invokes
+@code{free} only once.
+
+Notice that a Bison-generated parser invokes the default @code{%destructor}
+only for user-defined as opposed to Bison-defined symbols.
+For example, the parser will not invoke it for the special Bison-defined
+symbols @code{$accept}, @code{$undefined}, or @code{$end} (@pxref{Table of
+Symbols, ,Bison Symbols}), none of which you can reference in your grammar.
+It also will not invoke it for the @code{error} token (@pxref{Table of Symbols,
+,error}), which is always defined by Bison regardless of whether you reference
+it in your grammar.
+However, it will invoke it for the end token (token 0) if you redefine it from
+@code{$end} to, for example, @code{END}:
+
+@smallexample
+%token END 0
@end smallexample
+@ignore
@noindent
-guarantees that when a @code{STRING} or a @code{string} is discarded,
-its associated memory will be freed.
+In the future, it may be possible to redefine the @code{error} token as a
+nonterminal that captures the discarded symbols.
+In that case, the parser will invoke the default destructor for it as well.
+@end ignore
@sp 1
If the parser output file is named @file{@var{name}.c} then this file
is named @file{@var{name}.h}.
-Unless @code{YYSTYPE} is already defined as a macro, the output header
-declares @code{YYSTYPE}. Therefore, if you are using a @code{%union}
+For C parsers, the output header declares @code{YYSTYPE} unless
+@code{YYSTYPE} is already defined as a macro or you have used a
+@code{<@var{type}>} tag without using @code{%union}.
+Therefore, if you are using a @code{%union}
(@pxref{Multiple Types, ,More Than One Value Type}) with components that
require other definitions, or if you have defined a @code{YYSTYPE} macro
+or type definition
(@pxref{Value Type, ,Data Types of Semantic Values}), you need to
arrange for these definitions to be propagated to all modules, e.g., by
putting them in a prerequisite header that is included both by your
If you have also used locations, the output header declares
@code{YYLTYPE} and @code{yylloc} using a protocol similar to that of
-@code{YYSTYPE} and @code{yylval}. @xref{Locations, ,Tracking
+the @code{YYSTYPE} macro and @code{yylval}. @xref{Locations, ,Tracking
Locations}.
This output file is normally essential if you wish to put the definition
and to the token type codes. @xref{Token Values, ,Semantic Values of
Tokens}.
-@findex %start-header
-@findex %end-header
-If you have declared @code{%start-header} or @code{%end-header}, the output
+@findex %requires
+@findex %provides
+If you have declared @code{%requires} or @code{%provides}, the output
header also contains their code.
-@xref{Table of Symbols, ,%start-header}.
+@xref{Table of Symbols, ,%requires}.
@end deffn
@deffn {Directive} %destructor
Bison parsers are @dfn{shift/reduce automata}. In some cases (much more
frequent than one would hope), looking at this automaton is required to
tune or simply fix a parser. Bison provides two different
-representation of it, either textually or graphically (as a @acronym{VCG}
-file).
+representation of it, either textually or graphically (as a DOT file).
The textual file is generated when the options @option{--report} or
@option{--verbose} are specified, see @xref{Invocation, , Invoking
@var{format} and @var{args} are the usual @code{printf} format and
arguments. If you define @code{YYDEBUG} to a nonzero value but do not
define @code{YYFPRINTF}, @code{<stdio.h>} is automatically included
-and @code{YYPRINTF} is defined to @code{fprintf}.
+and @code{YYFPRINTF} is defined to @code{fprintf}.
Once you have compiled the program with trace facilities, the way to
request a trace is to store a nonzero value in the variable @code{yydebug}.
@item -b @var{file-prefix}
@itemx --file-prefix=@var{prefix}
-Pretend that @code{%file-prefix} was specified, i.e, specify prefix to use
+Pretend that @code{%file-prefix} was specified, i.e., specify prefix to use
for all Bison output file names. @xref{Decl Summary}.
@item -r @var{things}
@item -v
@itemx --verbose
-Pretend that @code{%verbose} was specified, i.e, write an extra output
+Pretend that @code{%verbose} was specified, i.e., write an extra output
file containing verbose descriptions of the grammar and
parser. @xref{Decl Summary}.
described under the @samp{-v} and @samp{-d} options.
@item -g
-Output a @acronym{VCG} definition of the @acronym{LALR}(1) grammar
-automaton computed by Bison. If the grammar file is @file{foo.y}, the
-@acronym{VCG} output file will
-be @file{foo.vcg}.
+Output a graphical representation of the @acronym{LALR}(1) grammar
+automaton computed by Bison, in @uref{http://www.graphviz.org/, Graphviz}
+@uref{http://www.graphviz.org/doc/info/lang.html, @acronym{DOT}} format.
+If the grammar file is @file{foo.y}, the output file will
+be @file{foo.dot}.
@item --graph=@var{graph-file}
The behavior of @var{--graph} is the same than @samp{-g}. The only
@comment file: calc++-driver.hh
@example
-// Announce to Flex the prototype we want for lexing function, ...
-# define YY_DECL \
+// Tell Flex the lexer's prototype ...
+# define YY_DECL \
yy::calcxx_parser::token_type \
yylex (yy::calcxx_parser::semantic_type* yylval, \
yy::calcxx_parser::location_type* yylloc, \
@noindent
To encapsulate the coordination with the Flex scanner, it is useful to
have two members function to open and close the scanning phase.
-members.
@comment file: calc++-driver.hh
@example
@end example
@noindent
-@findex %start-header
+@findex %requires
Then come the declarations/inclusions needed to define the
@code{%union}. Because the parser uses the parsing driver and
reciprocally, both cannot include the header of the other. Because the
driver's header needs detailed knowledge about the parser class (in
particular its inner types), it is the parser's header which will simply
use a forward declaration of the driver.
-@xref{Table of Symbols, ,%start-header}.
+@xref{Table of Symbols, ,%requires}.
@comment file: calc++-parser.yy
@example
-%start-header @{
+%requires @{
# include <string>
class calcxx_driver;
@}
@end example
@noindent
-@findex %after-header
-The code between @samp{%after-header @{} and @samp{@}} is output in the
+@findex %code
+The code between @samp{%code @{} and @samp{@}} is output in the
@file{*.cc} file; it needs detailed knowledge about the driver.
@comment file: calc++-parser.yy
@example
-%after-header @{
+%code @{
# include "calc++-driver.hh"
@}
@end example
assignments: assignments assignment @{@}
| /* Nothing. */ @{@};
-assignment: "identifier" ":=" exp @{ driver.variables[*$1] = $3; @};
+assignment:
+ "identifier" ":=" exp
+ @{ driver.variables[*$1] = $3; delete $1; @};
%left '+' '-';
%left '*' '/';
| exp '-' exp @{ $$ = $1 - $3; @}
| exp '*' exp @{ $$ = $1 * $3; @}
| exp '/' exp @{ $$ = $1 / $3; @}
- | "identifier" @{ $$ = driver.variables[*$1]; @}
+ | "identifier" @{ $$ = driver.variables[*$1]; delete $1; @}
| "number" @{ $$ = $1; @};
%%
@end example
driver.trace_scanning = true;
else
@{
- driver.parse (*argv);
- std::cout << driver.result << std::endl;
+ driver.parse (*argv);
+ std::cout << driver.result << std::endl;
@}
@}
@end example
Start-Symbol}. It cannot be used in the grammar.
@end deffn
-@deffn {Directive} %after-header @{@var{code}@}
-Specifies code to be inserted into the code file after the contents of the
-header file.
-@xref{Table of Symbols, ,%start-header}.
-@end deffn
-
-@deffn {Directive} %before-header @{@var{code}@}
-Specifies code to be inserted into the code file before the contents of the
-header file.
-@xref{Table of Symbols, ,%start-header}.
-@end deffn
-
-@deffn {Directive} %end-header @{@var{code}@}
-Specifies code to be inserted both into the header file (if generated;
-@pxref{Table of Symbols, ,%defines}) and into the code file after any
-Bison-generated definitions.
-@xref{Table of Symbols, ,%start-header}.
-@end deffn
-
-@deffn {Directive} %start-header @{@var{code}@}
-Specifies code to be inserted both into the header file (if generated;
-@pxref{Table of Symbols, ,%defines}) and into the code file before any
-Bison-generated definitions.
+@deffn {Directive} %code @{@var{code}@}
+Other than semantic actions, this is probably the most common place you should
+write verbatim code for the parser implementation.
+For C/C++, it replaces the traditional Yacc prologue,
+@code{%@{@var{code}%@}}, for most purposes.
+For Java, it inserts code into the parser class.
@cindex Prologue
-@findex %before-header
@findex %union
-@findex %end-header
-@findex %after-header
-For example, the following declaration order in the grammar file reflects the
-order in which Bison will output these code blocks. However, you are free to
-declare these code blocks in your grammar file in whatever order is most
-convenient for you:
+Compare with @code{%@{@var{code}%@}} (@pxref{Prologue, ,The Prologue})
+appearing after the first @code{%union @{@var{code}@}} in a C/C++ based grammar
+file.
+While Bison will continue to support @code{%@{@var{code}%@}} for backward
+compatibility, @code{%code @{@var{code}@}} is cleaner as its functionality does
+not depend on its position in the grammar file relative to any
+@code{%union @{@var{code}@}}.
+Specifically, @code{%code @{@var{code}@}} always inserts your @var{code} into
+the parser code file after the usual contents of the parser header file.
+
+@xref{Prologue Alternatives}.
+@end deffn
+
+@deffn {Directive} %code-top @{@var{code}@}
+Occasionally for C/C++ it is desirable to insert code near the top of the
+parser code file.
+For example:
@smallexample
-%before-header @{
- /* Bison treats this block like a pre-prologue block: it inserts it
- * into the code file before the contents of the header file. It
- * does *not* insert it into the header file. This is a good place
- * to put #include's that you want at the top of your code file. A
- * common example is `#include "system.h"'. */
-@}
-%start-header @{
- /* Bison inserts this block into both the header file and the code
- * file. In both files, the point of insertion is before any
- * Bison-generated token, semantic type, location type, and class
- * definitions. This is a good place to define %union
- * dependencies, for example. */
-@}
-%union @{
- /* Unlike the traditional Yacc prologue blocks, the output order
- * for the %*-header blocks is not affected by their declaration
- * position relative to any %union in the grammar file. */
-@}
-%end-header @{
- /* Bison inserts this block into both the header file and the code
- * file. In both files, the point of insertion is after the
- * Bison-generated definitions. This is a good place to declare or
- * define public functions or data structures that depend on the
- * Bison-generated definitions. */
-@}
-%after-header @{
- /* Bison treats this block like a post-prologue block: it inserts
- * it into the code file after the contents of the header file. It
- * does *not* insert it into the header file. This is a good place
- * to declare or define internal functions or data structures that
- * depend on the Bison-generated definitions. */
+%code-top @{
+ #define _GNU_SOURCE
+ #include <stdio.h>
@}
@end smallexample
-If you have multiple occurrences of any one of the above declarations, Bison
-will concatenate the contents in declaration order.
+@noindent
+For Java, @code{%code-top @{@var{code}@}} is currently unused.
+
+@cindex Prologue
+@findex %union
+Compare with @code{%@{@var{code}%@}} appearing before the first
+@code{%union @{@var{code}@}} in a C/C++ based grammar file.
+@code{%code-top @{@var{code}@}} is cleaner as its functionality does not depend
+on its position in the grammar file relative to any
+@code{%union @{@var{code}@}}.
-@xref{Prologue, ,The Prologue}.
+@xref{Prologue Alternatives}.
@end deffn
@deffn {Directive} %debug
@xref{Contextual Precedence, ,Context-Dependent Precedence}.
@end deffn
+@deffn {Directive} %provides @{@var{code}@}
+This is the right place to write additional definitions you would like Bison to
+expose externally.
+For C/C++, this directive inserts your @var{code} both into the parser header
+file (if generated; @pxref{Table of Symbols, ,%defines}) and into the parser
+code file after Bison's required definitions.
+For Java, it inserts your @var{code} into the parser java file after the parser
+class.
+
+@xref{Prologue Alternatives}.
+@end deffn
+
@deffn {Directive} %pure-parser
Bison declaration to request a pure (reentrant) parser.
@xref{Pure Decl, ,A Pure (Reentrant) Parser}.
Require a Version of Bison}.
@end deffn
+@deffn {Directive} %requires @{@var{code}@}
+This is the right place to write dependency code for externally exposed
+definitions required by Bison.
+For C/C++, such exposed definitions are those usually appearing in the parser
+header file.
+Thus, this is the right place to define types referenced in
+@code{%union @{@var{code}@}} directives, and it is the right place to override
+Bison's default @code{YYSTYPE} and @code{YYLTYPE} definitions.
+For Java, this is the right place to write import directives.
+
+@cindex Prologue
+@findex %union
+Compare with @code{%@{@var{code}%@}} (@pxref{Prologue, ,The Prologue})
+appearing before the first @code{%union @{@var{code}@}} in a C/C++ based
+grammar file.
+Unlike @code{%@{@var{code}%@}}, @code{%requires @{@var{code}@}} inserts your
+@var{code} both into the parser code file and into the parser header file (if
+generated; @pxref{Table of Symbols, ,%defines}) since Bison's required
+definitions should depend on it in both places.
+
+@xref{Prologue Alternatives}.
+@end deffn
+
@deffn {Directive} %right
Bison declaration to assign right associativity to token(s).
@xref{Precedence Decl, ,Operator Precedence}.
Start-Symbol}.
@end deffn
+@deffn {Directive} %symbol-default
+Used to declare a default @code{%destructor} or default @code{%printer}.
+@xref{Destructor Decl, , Freeing Discarded Symbols}.
+@end deffn
+
@deffn {Directive} %token
Bison declaration to declare token(s) without specifying precedence.
@xref{Token Decl, ,Token Type Names}.
@c LocalWords: strncmp intval tindex lvalp locp llocp typealt YYBACKUP
@c LocalWords: YYEMPTY YYEOF YYRECOVERING yyclearin GE def UMINUS maybeword
@c LocalWords: Johnstone Shamsa Sadaf Hussain Tomita TR uref YYMAXDEPTH
-@c LocalWords: YYINITDEPTH stmnts ref stmnt initdcl maybeasm VCG notype
+@c LocalWords: YYINITDEPTH stmnts ref stmnt initdcl maybeasm notype
@c LocalWords: hexflag STR exdent itemset asis DYYDEBUG YYFPRINTF args
-@c LocalWords: YYPRINTF infile ypp yxx outfile itemx vcg tex leaderfill
+@c LocalWords: infile ypp yxx outfile itemx tex leaderfill
@c LocalWords: hbox hss hfill tt ly yyin fopen fclose ofirst gcc ll
@c LocalWords: yyrestart nbar yytext fst snd osplit ntwo strdup AST
@c LocalWords: YYSTACK DVI fdl printindex
projects / bison.git / blobdiff