This manual (@value{UPDATED}) is for GNU Bison (version
@value{VERSION}), the GNU parser generator.
-Copyright @copyright{} 1988-1993, 1995, 1998-2014 Free Software
+Copyright @copyright{} 1988-1993, 1995, 1998-2015 Free Software
Foundation, Inc.
@quotation
@noindent
specifies the union tag @code{value}, so the corresponding C type is
@code{union value}. If you do not specify a tag, it defaults to
-@code{YYSTYPE}.
+@code{YYSTYPE} (@pxref{%define Summary,,api.value.union.name}).
As another extension to POSIX, you may specify multiple @code{%union}
declarations; their contents are concatenated. However, only the first
@code{string1}, it formats it as a string in double quotes. It performs
only the second @code{%printer} in this case, so it prints only once.
Finally, the parser print @samp{<>} for any symbol, such as @code{TAGLESS},
-that has no semantic type tag. See also
+that has no semantic type tag. @xref{Mfcalc Traces, ,Enabling Debug Traces
+for @code{mfcalc}}, for a complete example.
+
@node Expect Decl
@item Default Value:
@itemize @minus
@item
-@code{%union} if @code{%union} is used, otherwise @dots{}
+@code{union-directive} if @code{%union} is used, otherwise @dots{}
@item
@code{int} if type tags are used (i.e., @samp{%token <@var{type}>@dots{}} or
-@samp{%token <@var{type}>@dots{}} is used), otherwise @dots{}
+@samp{%type <@var{type}>@dots{}} is used), otherwise @dots{}
@item
-@code{""}
+undefined.
@end itemize
@item History:
@c api.value.type
+@c ================================================== api.value.union.name
+@deffn Directive {%define api.value.union.name} @var{name}
+@itemize @bullet
+@item Language(s):
+C
+
+@item Purpose:
+The tag of the generated @code{union} (@emph{not} the name of the
+@code{typedef}). This variable is set to @code{@var{id}} when @samp{%union
+@var{id}} is used. There is no clear reason to give this union a name.
+
+@item Accepted Values:
+Any valid identifier.
+
+@item Default Value:
+@code{YYSTYPE}.
+
+@item History:
+Introduced in Bison 3.0.3.
+@end itemize
+@end deffn
+@c api.value.type
+
+
@c ================================================== location_type
@deffn Directive {%define location_type}
Obsoleted by @code{api.location.type} since Bison 2.7.
The unary-minus is another typical example where associativity is
usually over-specified, see @ref{Infix Calc, , Infix Notation
-Calculator: @code{calc}}. The @code{%left} directive is traditionally
+Calculator - @code{calc}}. The @code{%left} directive is traditionally
used to declare the precedence of @code{NEG}, which is more than needed
since it also defines its associativity. While this is harmless in the
traditional example, who knows how @code{NEG} might be used in future
int yyerror (char const *);
@end example
-Bison ignores the @code{int} value returned by this @code{yyerror}.
-If you use the Yacc library's @code{main} function, your
-@code{yyparse} function should have the following type signature:
+@noindent
+The @code{int} value returned by this @code{yyerror} is ignored.
+
+The implementation of Yacc library's @code{main} function is:
+
+@example
+int main (void)
+@{
+ setlocale (LC_ALL, "");
+ return yyparse ();
+@}
+@end example
+
+@noindent
+so if you use it, the internationalization support is enabled (e.g., error
+messages are translated), and your @code{yyparse} function should have the
+following type signature:
@example
int yyparse (void);
Forwarded to the @code{end} position.
@end deftypemethod
-@deftypemethod {location} {location} operator+ (const location& @var{end})
-@deftypemethodx {location} {location} operator+ (int @var{width})
+@deftypemethod {location} {location} operator+ (int @var{width})
@deftypemethodx {location} {location} operator+= (int @var{width})
-@deftypemethodx {location} {location} operator- (int @var{width})
+@deftypemethodx {location} {location} operator- (int @var{width})
@deftypemethodx {location} {location} operator-= (int @var{width})
-Various forms of syntactic sugar.
+Various forms of syntactic sugar for @code{columns}.
+@end deftypemethod
+
+@deftypemethod {location} {location} operator+ (const location& @var{end})
+@deftypemethodx {location} {location} operator+= (const location& @var{end})
+Join two locations: starts at the position of the first one, and ends at the
+position of the second.
@end deftypemethod
@deftypemethod {location} {void} step ()
in order to compute the (default) value of @code{@@$} in a reduction, the
parser basically runs
@example
-@@$.begin = @@$1.begin;
-@@$.end = @@$@var{N}.end; // The location of last right-hand side symbol.
+@@$.begin = @@1.begin;
+@@$.end = @@@var{N}.end; // The location of last right-hand side symbol.
@end example
@noindent
so there must be copyable @code{begin} and @code{end} members;
@example
[0-9]+ @{
- yylval.ival = text_to_int (yytext);
- return yy::parser::INTEGER;
+ yylval->ival = text_to_int (yytext);
+ return yy::parser::token::INTEGER;
@}
[a-z]+ @{
- yylval.sval = new std::string (yytext);
- return yy::parser::IDENTIFIER;
+ yylval->sval = new std::string (yytext);
+ return yy::parser::token::IDENTIFIER;
@}
@end example
@example
[0-9]+ @{
- yylval.build<int>() = text_to_int (yytext);
- return yy::parser::INTEGER;
+ yylval->build<int> () = text_to_int (yytext);
+ return yy::parser::token::INTEGER;
@}
[a-z]+ @{
- yylval.build<std::string> = yytext;
- return yy::parser::IDENTIFIER;
+ yylval->build<std::string> () = yytext;
+ return yy::parser::token::IDENTIFIER;
@}
@end example
@example
[0-9]+ @{
- yylval.build(text_to_int (yytext));
- return yy::parser::INTEGER;
+ yylval->build (text_to_int (yytext));
+ return yy::parser::token::INTEGER;
@}
[a-z]+ @{
- yylval.build(yytext);
- return yy::parser::IDENTIFIER;
+ yylval->build (yytext);
+ return yy::parser::token::IDENTIFIER;
@}
@end example
So for each token type, Bison generates named constructors as follows.
-@deftypemethod {symbol_type} {} make_@var{token} (const @var{value_type}& @var{value}, const location_type& @var{location})
-@deftypemethodx {symbol_type} {} make_@var{token} (const location_type& @var{location})
+@deftypemethod {symbol_type} {} {make_@var{token}} (const @var{value_type}& @var{value}, const location_type& @var{location})
+@deftypemethodx {symbol_type} {} {make_@var{token}} (const location_type& @var{location})
Build a complete terminal symbol for the token type @var{token} (not
including the @code{api.token.prefix}) whose possible semantic value is
@var{value} of adequate @var{value_type}. If location tracking is enabled,
Bison generates the following functions:
@example
-symbol_type make_IDENTIFIER(const std::string& v,
- const location_type& l);
-symbol_type make_INTEGER(const int& v,
- const location_type& loc);
-symbol_type make_COLON(const location_type& loc);
+symbol_type make_IDENTIFIER (const std::string&, const location_type&);
+symbol_type make_INTEGER (const int&, const location_type&);
+symbol_type make_COLON (const location_type&);
@end example
@noindent
which should be used in a Lex-scanner as follows.
@example
-[0-9]+ return yy::parser::make_INTEGER(text_to_int (yytext), loc);
-[a-z]+ return yy::parser::make_IDENTIFIER(yytext, loc);
-":" return yy::parser::make_COLON(loc);
+[0-9]+ return yy::parser::make_INTEGER (text_to_int (yytext), loc);
+[a-z]+ return yy::parser::make_IDENTIFIER (yytext, loc);
+":" return yy::parser::make_COLON (loc);
@end example
Tokens that do not have an identifier are not accessible: you cannot simply
@noindent
The grammar itself is straightforward (@pxref{Location Tracking Calc, ,
-Location Tracking Calculator: @code{ltcalc}}).
+Location Tracking Calculator - @code{ltcalc}}).
@comment file: calc++-parser.yy
@example
@comment file: calc++-scanner.ll
@example
-"-" return yy::calcxx_parser::make_MINUS(loc);
-"+" return yy::calcxx_parser::make_PLUS(loc);
-"*" return yy::calcxx_parser::make_STAR(loc);
-"/" return yy::calcxx_parser::make_SLASH(loc);
-"(" return yy::calcxx_parser::make_LPAREN(loc);
-")" return yy::calcxx_parser::make_RPAREN(loc);
-":=" return yy::calcxx_parser::make_ASSIGN(loc);
+"-" return yy::calcxx_parser::make_MINUS (loc);
+"+" return yy::calcxx_parser::make_PLUS (loc);
+"*" return yy::calcxx_parser::make_STAR (loc);
+"/" return yy::calcxx_parser::make_SLASH (loc);
+"(" return yy::calcxx_parser::make_LPAREN (loc);
+")" return yy::calcxx_parser::make_RPAREN (loc);
+":=" return yy::calcxx_parser::make_ASSIGN (loc);
@group
@{int@} @{
long n = strtol (yytext, NULL, 10);
if (! (INT_MIN <= n && n <= INT_MAX && errno != ERANGE))
driver.error (loc, "integer is out of range");
- return yy::calcxx_parser::make_NUMBER(n, loc);
+ return yy::calcxx_parser::make_NUMBER (n, loc);
@}
@end group
-@{id@} return yy::calcxx_parser::make_IDENTIFIER(yytext, loc);
+@{id@} return yy::calcxx_parser::make_IDENTIFIER (yytext, loc);
. driver.error (loc, "invalid character");
-<<EOF>> return yy::calcxx_parser::make_END(loc);
+<<EOF>> return yy::calcxx_parser::make_END (loc);
%%
@end example
projects / bison.git / blobdiff