@value{UPDATED}), the @acronym{GNU} parser generator.
Copyright @copyright{} 1988, 1989, 1990, 1991, 1992, 1993, 1995, 1998,
-1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
@quotation
Permission is granted to copy, distribute and/or modify this document
@cindex Prologue Alternatives
@findex %code
-@findex %requires
-@findex %provides
-@findex %code-top
+@findex %code requires
+@findex %code provides
+@findex %code top
(The prologue alternatives described here are experimental.
More user feedback will help to determine whether they should become permanent
features.)
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}, @code{%requires}, @code{%provides}, and @code{%code-top}.
-@xref{Table of Symbols,,Bison Symbols}.
+As an alternative, Bison provides a %code directive with an explicit qualifier
+field, which identifies the purpose of the code and thus the location(s) where
+Bison should generate it.
+For C/C++, the qualifier can be omitted for the default location, or it can be
+@code{requires}, @code{provides}, or @code{top}.
+@xref{Decl Summary,,%code}.
Look again at the example of the previous section:
@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.
+parser source 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?
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}.
+To avoid this subtle @code{%union} dependency, rewrite the example using a
+@code{%code top} and an unqualified @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 @{
+%code top @{
#define _GNU_SOURCE
#include <stdio.h>
- /* The following code really belongs in a %requires; see below. */
+
+ /* WARNING: The following code really belongs
+ * in a `%code requires'; see below. */
+
#include "ptypes.h"
#define YYLTYPE YYLTYPE
typedef struct YYLTYPE
@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.
+In this way, @code{%code top} and the unqualified @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 @code{%code-top} block above 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.
+The @code{%code top} block above logically contains two parts.
+The first two lines before the warning need to appear near the top of the
+parser source code file.
+The first line after the warning is required by @code{YYSTYPE} and thus also
+needs to appear in the parser source code file.
However, if you've instructed Bison to generate a parser header file
-(@pxref{Table of Symbols, ,%defines}), you probably want the fourth 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
+(@pxref{Decl Summary, ,%defines}), you probably want that line to appear before
+the @code{YYSTYPE} definition in that header file as well.
+The @code{YYLTYPE} definition should also appear in the parser header file to
override the default @code{YYLTYPE} definition there.
-In other words, in the @code{%code-top} block above, 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}:
+In other words, in the @code{%code top} block above, all but the first two
+lines are dependency code required by the @code{YYSTYPE} and @code{YYLTYPE}
+definitions.
+Thus, they belong in one or more @code{%code requires}:
@smallexample
-%code-top @{
+%code top @{
#define _GNU_SOURCE
#include <stdio.h>
@}
-%requires @{
+%code requires @{
#include "ptypes.h"
@}
%union @{
tree t; /* @r{@code{tree} is defined in @file{ptypes.h}.} */
@}
-%requires @{
+%code requires @{
#define YYLTYPE YYLTYPE
typedef struct YYLTYPE
@{
@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}.)
+definitions in both the parser source code file and the parser header file.
+(By the same reasoning, @code{%code requires} would also be the appropriate
+place to write your own definition for @code{YYSTYPE}.)
When you are writing dependency code for @code{YYSTYPE} and @code{YYLTYPE}, you
-should prefer @code{%requires} over @code{%code-top} regardless of whether you
-instruct Bison to generate a parser header file.
+should prefer @code{%code requires} over @code{%code top} regardless of whether
+you instruct Bison to generate a parser header file.
When you are writing code that you need Bison to insert only into the parser
-code file and that has no special need to appear at the top of the code file,
-you should prefer @code{%code} over @code{%code-top}.
+source code file and that has no special need to appear at the top of that
+file, you should prefer the unqualified @code{%code} over @code{%code top}.
These practices will make the purpose of each block of your code explicit to
Bison and to other developers reading your grammar file.
-Following these practices, we expect @code{%code} and @code{%requires} to be
-the most important of the four @var{Prologue} alternative directives discussed
-in this section.
+Following these practices, we expect the unqualified @code{%code} and
+@code{%code requires} to be the most important of the four @var{Prologue}
+alternatives.
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}.
+header file and the parser source code file.
+Since this function is not a dependency required by @code{YYSTYPE} or
+@code{YYLTYPE}, it doesn't make sense to move its prototype to a
+@code{%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}:
+@code{%code requires} is not sufficient.
+Instead, move its prototype from the unqualified @code{%code} to a
+@code{%code provides}:
@smallexample
-%code-top @{
+%code top @{
#define _GNU_SOURCE
#include <stdio.h>
@}
-%requires @{
+%code requires @{
#include "ptypes.h"
@}
%union @{
tree t; /* @r{@code{tree} is defined in @file{ptypes.h}.} */
@}
-%requires @{
+%code requires @{
#define YYLTYPE YYLTYPE
typedef struct YYLTYPE
@{
@} YYLTYPE;
@}
-%provides @{
+%code provides @{
void trace_token (enum yytokentype token, YYLTYPE loc);
@}
@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}.
+file and the parser source 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}.
+the layout of the generated parser source code and header files:
+@code{%code top}, @code{%code requires}, @code{%code provides}, and then
+@code{%code}.
While your grammar files may 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.
type:
@smallexample
-%requires @{ #include "type1.h" @}
+%code requires @{ #include "type1.h" @}
%union @{ type1 field1; @}
%destructor @{ type1_free ($$); @} <field1>
%printer @{ type1_print ($$); @} <field1>
-%requires @{ #include "type2.h" @}
+%code requires @{ #include "type2.h" @}
%union @{ type2 field2; @}
%destructor @{ type2_free ($$); @} <field2>
%printer @{ type2_print ($$); @} <field2>
Such an organization is not possible using @var{Prologue} sections.
This section has been concerned with explaining the advantages of the four
-@var{Prologue} alternative directives over the original Yacc @var{Prologue}.
+@var{Prologue} alternatives over the original Yacc @var{Prologue}.
However, in most cases when using these directives, you shouldn't need to
think about all the low-level ordering issues discussed here.
Instead, you should simply use these directives to label each block of your
code according to its purpose and let Bison handle the ordering.
@code{%code} is the most generic label.
-Move code to @code{%requires}, @code{%provides}, or @code{%code-top} as needed.
+Move code to @code{%code requires}, @code{%code provides}, or @code{%code top}
+as needed.
@node Bison Declarations
@subsection The Bison Declarations Section
In order to change the behavior of @command{bison}, use the following
directives:
+@deffn {Directive} %code @{@var{code}@}
+@findex %code
+This is the unqualified form of the @code{%code} directive.
+It inserts @var{code} verbatim at the default location in the output.
+That default location is determined by the selected target language and/or
+parser skeleton.
+
+@cindex Prologue
+For the current C/C++ skeletons, the default location is the parser source code
+file after the usual contents of the parser header file.
+Thus, @code{%code} replaces the traditional Yacc prologue,
+@code{%@{@var{code}%@}}, for most purposes.
+For a detailed discussion, see @ref{Prologue Alternatives}.
+
+@comment For Java, the default location is inside the parser class.
+
+(Like all the Yacc prologue alternatives, this directive is experimental.
+More user feedback will help to determine whether it should become a permanent
+feature.)
+@end deffn
+
+@deffn {Directive} %code @var{qualifier} @{@var{code}@}
+This is the qualified form of the @code{%code} directive.
+If you need to specify location-sensitive verbatim @var{code} that does not
+belong at the default location selected by the unqualified @code{%code} form,
+use this form instead.
+
+@var{qualifier} identifies the purpose of @var{code} and thus the location(s)
+where Bison should generate it.
+Not all values of @var{qualifier} are available for all target languages:
+
+@itemize @bullet
+@findex %code requires
+@item requires
+
+@itemize @bullet
+@item Language(s): C, C++
+
+@item Purpose: This is the best place to write dependency code required for
+@code{YYSTYPE} and @code{YYLTYPE}.
+In other words, it's the best place to define types referenced in @code{%union}
+directives, and it's the best place to override Bison's default @code{YYSTYPE}
+and @code{YYLTYPE} definitions.
+
+@item Location(s): The parser header file and the parser source code file
+before the Bison-generated @code{YYSTYPE} and @code{YYLTYPE} definitions.
+@end itemize
+
+@item provides
+@findex %code provides
+
+@itemize @bullet
+@item Language(s): C, C++
+
+@item Purpose: This is the best place to write additional definitions and
+declarations that should be provided to other modules.
+
+@item Location(s): The parser header file and the parser source code file after
+the Bison-generated @code{YYSTYPE}, @code{YYLTYPE}, and token definitions.
+@end itemize
+
+@item top
+@findex %code top
+
+@itemize @bullet
+@item Language(s): C, C++
+
+@item Purpose: The unqualified @code{%code} or @code{%code requires} should
+usually be more appropriate than @code{%code top}.
+However, occasionally it is necessary to insert code much nearer the top of the
+parser source code file.
+For example:
+
+@smallexample
+%code top @{
+ #define _GNU_SOURCE
+ #include <stdio.h>
+@}
+@end smallexample
+
+@item Location(s): Near the top of the parser source code file.
+@end itemize
+@ignore
+@item imports
+@findex %code imports
+
+@itemize @bullet
+@item Language(s): Java
+
+@item Purpose: This is the best place to write Java import directives.
+
+@item Location(s): The parser Java file after any Java package directive and
+before any class definitions.
+@end itemize
+@end ignore
+@end itemize
+
+(Like all the Yacc prologue alternatives, this directive is experimental.
+More user feedback will help to determine whether it should become a permanent
+feature.)
+
+@cindex Prologue
+For a detailed discussion of how to use @code{%code} in place of the
+traditional Yacc prologue for C/C++, see @ref{Prologue Alternatives}.
+@end deffn
+
@deffn {Directive} %debug
In the parser file, define the macro @code{YYDEBUG} to 1 if it is not
already defined, so that the debugging facilities are compiled.
@end deffn
@xref{Tracing, ,Tracing Your Parser}.
+@deffn {Directive} %define @var{define-variable}
+@deffnx {Directive} %define @var{define-variable} @var{value}
+Define a variable to adjust Bison's behavior.
+The list of available variables and their meanings depends on the selected
+target language and/or the parser skeleton (@pxref{Decl Summary,,%language}).
+The @var{value} can be omitted for boolean variables; for
+boolean variables, the skeletons will treat a @var{value} of @samp{0}
+or @samp{false} as the boolean variable being false, and anything else
+as true.
+@end deffn
+
@deffn {Directive} %defines
Write a header file containing macro definitions for the token type
names defined in the grammar as well as a few other declarations.
and to the token type codes. @xref{Token Values, ,Semantic Values of
Tokens}.
-@findex %requires
-@findex %provides
-If you have declared @code{%requires} or @code{%provides}, the output
+@findex %code requires
+@findex %code provides
+If you have declared @code{%code requires} or @code{%code provides}, the output
header also contains their code.
-@xref{Table of Symbols, ,%requires}.
+@xref{Decl Summary, ,%code}.
@end deffn
@deffn {Directive} %defines @var{defines-file}
@end deffn
@deffn {Directive} %skeleton "@var{file}"
-Specify the skeleton to use. You probably don't need this option unless
-you are developing Bison; you should use @code{%language} if you want to
-specify the skeleton for a different language, because it is clearer and
-because it will always choose the correct skeleton for non-deterministic
-or push parsers.
+Specify the skeleton to use.
+
+You probably don't need this option unless you are developing Bison.
+You should use @code{%language} if you want to specify the skeleton for a
+different language, because it is clearer and because it will always choose the
+correct skeleton for non-deterministic or push parsers.
+
+If @var{file} does not contain a @code{/}, @var{file} is the name of a skeleton
+file in the Bison installation directory.
+If it does, @var{file} is an absolute file name or a file name relative to the
+directory of the grammar file.
+This is similar to how most shells resolve commands.
@end deffn
@deffn {Directive} %token-table
@item -S @var{file}
@itemx --skeleton=@var{file}
-Specify the skeleton to use, as if @code{%skeleton} was specified
+Specify the skeleton to use, similar to @code{%skeleton}
(@pxref{Decl Summary, , Bison Declaration Summary}).
-You probably don't need this option unless you are developing Bison;
-you should use @option{--language} if you want to specify the skeleton for a
+You probably don't need this option unless you are developing Bison.
+You should use @option{--language} if you want to specify the skeleton for a
different language, because it is clearer and because it will always
choose the correct skeleton for non-deterministic or push parsers.
+If @var{file} does not contain a @code{/}, @var{file} is the name of a skeleton
+file in the Bison installation directory.
+If it does, @var{file} is an absolute file name or a file name relative to the
+current working directory.
+This is similar to how most shells resolve commands.
+
@item -k
@itemx --token-table
Pretend that @code{%token-table} was specified. @xref{Decl Summary}.
@c - %locations
@c - class Position
@c - class Location
-@c - %define "filename_type" "const symbol::Symbol"
+@c - %define filename_type "const symbol::Symbol"
When the directive @code{%locations} is used, the C++ parser supports
location tracking, see @ref{Locations, , Locations Overview}. Two
The name of the file. It will always be handled as a pointer, the
parser will never duplicate nor deallocate it. As an experimental
feature you may change it to @samp{@var{type}*} using @samp{%define
-"filename_type" "@var{type}"}.
+filename_type "@var{type}"}.
@end deftypemethod
@deftypemethod {position} {unsigned int} line
The output files @file{@var{output}.hh} and @file{@var{output}.cc}
declare and define the parser class in the namespace @code{yy}. The
class name defaults to @code{parser}, but may be changed using
-@samp{%define "parser_class_name" "@var{name}"}. The interface of
+@samp{%define parser_class_name "@var{name}"}. The interface of
this class is detailed below. It can be extended using the
@code{%parse-param} feature: its semantics is slightly changed since
it describes an additional member of the parser class, and an
@comment file: calc++-driver.hh
@example
- // Handling the parser.
- void parse (const std::string& f);
+ // Run the parser. Return 0 on success.
+ int parse (const std::string& f);
std::string file;
bool trace_parsing;
@end example
@{
@}
-void
+int
calcxx_driver::parse (const std::string &f)
@{
file = f;
scan_begin ();
yy::calcxx_parser parser (*this);
parser.set_debug_level (trace_parsing);
- parser.parse ();
+ int res = parser.parse ();
scan_end ();
+ return res;
@}
void
%language "C++" /* -*- C++ -*- */
%require "@value{VERSION}"
%defines
-%define "parser_class_name" "calcxx_parser"
+%define parser_class_name "calcxx_parser"
@end example
@noindent
-@findex %requires
+@findex %code 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, ,%requires}.
+@xref{Decl Summary, ,%code}.
@comment file: calc++-parser.yy
@example
-%requires @{
+%code requires @{
# include <string>
class calcxx_driver;
@}
%token ASSIGN ":="
%token <sval> IDENTIFIER "identifier"
%token <ival> NUMBER "number"
-%type <ival> exp "expression"
+%type <ival> exp
@end example
@noindent
%printer @{ debug_stream () << *$$; @} "identifier"
%destructor @{ delete $$; @} "identifier"
-%printer @{ debug_stream () << $$; @} "number" "expression"
+%printer @{ debug_stream () << $$; @} <ival>
@end example
@noindent
calcxx_driver::scan_begin ()
@{
yy_flex_debug = trace_scanning;
- if (!(yyin = fopen (file.c_str (), "r")))
- error (std::string ("cannot open ") + file);
+ if (file == "-")
+ yyin = stdin;
+ else if (!(yyin = fopen (file.c_str (), "r")))
+ @{
+ error (std::string ("cannot open ") + file);
+ exit (1);
+ @}
@}
void
driver.trace_parsing = true;
else if (*argv == std::string ("-s"))
driver.trace_scanning = true;
- else
- @{
- driver.parse (*argv);
- std::cout << driver.result << std::endl;
- @}
+ else if (!driver.parse (*argv))
+ std::cout << driver.result << std::endl;
@}
@end example
@end deffn
@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.
-It replaces the traditional Yacc prologue,
-@comment For C/C++, it replaces the traditional Yacc prologue,
-@code{%@{@var{code}%@}}, for most purposes.
-@comment For Java, it inserts code into the parser class.
-
-@cindex Prologue
-@findex %union
-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.
-
-(Like all the Yacc prologue alternative directives, this directive is
-experimental.
-More user feedback will help to determine whether it should become a permanent
-feature.)
-
-@xref{Prologue Alternatives}.
-@end deffn
-
-@deffn {Directive} %code-top @{@var{code}@}
-Occasionally it is desirable to insert code near the top of the
-@comment Occasionally for C/C++ it is desirable to insert code near the top of the
-parser code file.
-For example:
-
-@smallexample
-%code-top @{
- #define _GNU_SOURCE
- #include <stdio.h>
-@}
-@end smallexample
-
-@comment @noindent
-@comment 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}@}}.
-
-(Like all the Yacc prologue alternative directives, this directive is
-experimental.
-More user feedback will help to determine whether it should become a permanent
-feature.)
-
-@xref{Prologue Alternatives}.
+@deffnx {Directive} %code @var{qualifier} @{@var{code}@}
+Insert @var{code} verbatim into output parser source.
+@xref{Decl Summary,,%code}.
@end deffn
@deffn {Directive} %debug
@end deffn
@end ifset
+@deffn {Directive} %define @var{define-variable}
+@deffnx {Directive} %define @var{define-variable} @var{value}
+Define a variable to adjust Bison's behavior.
+@xref{Decl Summary,,%define}.
+@end deffn
+
@deffn {Directive} %defines
Bison declaration to create a header file meant for the scanner.
@xref{Decl Summary}.
@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.
-That is, this directive inserts your @var{code} both into the parser header
-@comment 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.
-@comment For Java, it inserts your @var{code} into the parser java file after the parser
-@comment class.
-
-(Like all the Yacc prologue alternative directives, this directive is
-experimental.
-More user feedback will help to determine whether it should become a permanent
-feature.)
-
-@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.
-Such exposed definitions are those usually appearing in the parser
-@comment 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.
-@comment 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.
-
-(Like all the Yacc prologue alternative directives, this directive is
-experimental.
-More user feedback will help to determine whether it should become a permanent
-feature.)
-
-@xref{Prologue Alternatives}.
-@end deffn
-
@deffn {Directive} %right
Bison declaration to assign right associativity to token(s).
@xref{Precedence Decl, ,Operator Precedence}.
projects / bison.git / blobdiff