X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/3add7b9cb180807ce3097c8965ab7adfad49630a..637fa3f83edca74df6a9d834ffe7bfd4d7468793:/doc/bison.texinfo diff --git a/doc/bison.texinfo b/doc/bison.texinfo index 93b93ed8..d09f42a8 100644 --- a/doc/bison.texinfo +++ b/doc/bison.texinfo @@ -237,7 +237,7 @@ The Lexical Analyzer Function @code{yylex} * Calling Convention:: How @code{yyparse} calls @code{yylex}. * Token Values:: How @code{yylex} must return the semantic value of the token it has read. -* Token Positions:: How @code{yylex} must return the text position +* Token Locations:: How @code{yylex} must return the text location (line number, etc.) of the token, if the actions want that. * Pure Calling:: How the calling convention differs @@ -284,6 +284,10 @@ Invoking Bison Frequently Asked Questions * Parser Stack Overflow:: Breaking the Stack Limits +* How Can I Reset @code{yyparse}:: @code{yyparse} Keeps some State +* Strings are Destroyed:: @code{yylval} Loses Track of Strings +* C++ Parsers:: Compiling Parsers with C++ Compilers +* Implementing Loops:: Control Flow in the Calculator Copying This Manual @@ -855,12 +859,12 @@ will suffice. Otherwise, we suggest @node Locations Overview @section Locations @cindex location -@cindex textual position -@cindex position, textual +@cindex textual location +@cindex location, textual Many applications, like interpreters or compilers, have to produce verbose and useful error messages. To achieve this, one must be able to keep track of -the @dfn{textual position}, or @dfn{location}, of each syntactic construct. +the @dfn{textual location}, or @dfn{location}, of each syntactic construct. Bison provides a mechanism for handling these locations. Each token has a semantic value. In a similar fashion, each token has an @@ -3071,8 +3075,8 @@ actually does to implement mid-rule actions. @node Locations @section Tracking Locations @cindex location -@cindex textual position -@cindex position, textual +@cindex textual location +@cindex location, textual Though grammar rules and semantic actions are enough to write a fully functional parser, it can be useful to process some additional information, @@ -3493,7 +3497,7 @@ is called when a symbol is thrown away. Declare that the @var{code} must be invoked for each of the @var{symbols} that will be discarded by the parser. The @var{code} should use @code{$$} to designate the semantic value associated to the -@var{symbols}. The additional parser parameters are also avaible +@var{symbols}. The additional parser parameters are also available (@pxref{Parser Function, , The Parser Function @code{yyparse}}). @strong{Warning:} as of Bison 1.875, this feature is still considered as @@ -3558,7 +3562,7 @@ The declaration looks like this: Here @var{n} is a decimal integer. The declaration says there should be no warning if there are @var{n} shift/reduce conflicts and no -reduce/reduce conflicts. An error, instead of the usual warning, is +reduce/reduce conflicts. The usual warning is given if there are either more or fewer conflicts, or if there are any reduce/reduce conflicts. @@ -3580,9 +3584,9 @@ Add an @code{%expect} declaration, copying the number @var{n} from the number which Bison printed. @end itemize -Now Bison will stop annoying you about the conflicts you have checked, but -it will warn you again if changes in the grammar result in additional -conflicts. +Now Bison will stop annoying you if you do not change the number of +conflicts, but it will warn you again if changes in the grammar result +in more or fewer conflicts. @node Start Decl @subsection The Start-Symbol @@ -3902,12 +3906,6 @@ Return immediately with value 0 (to report success). Return immediately with value 1 (to report failure). @end defmac -@c For now, do not document %lex-param and %parse-param, since it's -@c not clear that the current behavior is stable enough. For example, -@c we may need to add %error-param. -@clear documentparam - -@ifset documentparam If you use a reentrant parser, you can optionally pass additional parameter information to it in a reentrant way. To do so, use the declaration @code{%parse-param}: @@ -3946,7 +3944,6 @@ In the grammar actions, use expressions like this to refer to the data: @example exp: @dots{} @{ @dots{}; *randomness += 1; @dots{} @} @end example -@end ifset @node Lexical @@ -3971,7 +3968,7 @@ that need it. @xref{Invocation, ,Invoking Bison}. * Calling Convention:: How @code{yyparse} calls @code{yylex}. * Token Values:: How @code{yylex} must return the semantic value of the token it has read. -* Token Positions:: How @code{yylex} must return the text position +* Token Locations:: How @code{yylex} must return the text location (line number, etc.) of the token, if the actions want that. * Pure Calling:: How the calling convention differs @@ -4104,8 +4101,8 @@ then the code in @code{yylex} might look like this: @end group @end example -@node Token Positions -@subsection Textual Positions of Tokens +@node Token Locations +@subsection Textual Locations of Tokens @vindex yylloc If you are using the @samp{@@@var{n}}-feature (@pxref{Locations, , @@ -4148,12 +4145,11 @@ yylex (YYSTYPE *lvalp, YYLTYPE *llocp) @end example If the grammar file does not use the @samp{@@} constructs to refer to -textual positions, then the type @code{YYLTYPE} will not be defined. In +textual locations, then the type @code{YYLTYPE} will not be defined. In this case, omit the second argument; @code{yylex} will be called with only one argument. -@ifset documentparam If you wish to pass the additional parameter data to @code{yylex}, use @code{%lex-param} just like @code{%parse-param} (@pxref{Parser Function}). @@ -4194,7 +4190,6 @@ and finally, if both @code{%pure-parser} and @code{%locations} are used: int yylex (YYSTYPE *lvalp, YYLTYPE *llocp, int *nastiness); int yyparse (int *nastiness, int *randomness); @end example -@end ifset @node Error Reporting @section The Error Reporting Function @code{yyerror} @@ -4259,7 +4254,6 @@ void yyerror (char const *msg); /* Yacc parsers. */ void yyerror (YYLTYPE *locp, char const *msg); /* GLR parsers. */ @end example -@ifset documentparam If @samp{%parse-param @{int *nastiness@}} is used, then: @example @@ -4293,7 +4287,6 @@ void yyerror (YYLTYPE *locp, int *nastiness, int *randomness, char const *msg); @end example -@end ifset @noindent The prototypes are only indications of how the code produced by Bison @@ -4410,7 +4403,7 @@ errors. This is useful primarily in error rules. @deffn {Value} @@$ @findex @@$ -Acts like a structure variable containing information on the textual position +Acts like a structure variable containing information on the textual location of the grouping made by the current rule. @xref{Locations, , Tracking Locations}. @@ -4436,7 +4429,7 @@ Tracking Locations}. @deffn {Value} @@@var{n} @findex @@@var{n} -Acts like a structure variable containing information on the textual position +Acts like a structure variable containing information on the textual location of the @var{n}th component of the current rule. @xref{Locations, , Tracking Locations}. @end deffn @@ -6363,6 +6356,10 @@ are addressed. @menu * Parser Stack Overflow:: Breaking the Stack Limits +* How Can I Reset @code{yyparse}:: @code{yyparse} Keeps some State +* Strings are Destroyed:: @code{yylval} Loses Track of Strings +* C++ Parsers:: Compiling Parsers with C++ Compilers +* Implementing Loops:: Control Flow in the Calculator @end menu @node Parser Stack Overflow @@ -6376,6 +6373,204 @@ message. What can I do? This question is already addressed elsewhere, @xref{Recursion, ,Recursive Rules}. +@node How Can I Reset @code{yyparse} +@section How Can I Reset @code{yyparse} + +The following phenomenon has several symptoms, resulting in the +following typical questions: + +@display +I invoke @code{yyparse} several times, and on correct input it works +properly; but when a parse error is found, all the other calls fail +too. How can I reset the error flag of @code{yyparse}? +@end display + +@noindent +or + +@display +My parser includes support for an @samp{#include}-like feature, in +which case I run @code{yyparse} from @code{yyparse}. This fails +although I did specify I needed a @code{%pure-parser}. +@end display + +These problems typically come not from Bison itself, but from +Lex-generated scanners. Because these scanners use large buffers for +speed, they might not notice a change of input file. As a +demonstration, consider the following source file, +@file{first-line.l}: + +@verbatim +%{ +#include +#include +%} +%% +.*\n ECHO; return 1; +%% +int +yyparse (char const *file) +{ + yyin = fopen (file, "r"); + if (!yyin) + exit (2); + /* One token only. */ + yylex (); + if (fclose (yyin) != 0) + exit (3); + return 0; +} + +int +main (void) +{ + yyparse ("input"); + yyparse ("input"); + return 0; +} +@end verbatim + +@noindent +If the file @file{input} contains + +@verbatim +input:1: Hello, +input:2: World! +@end verbatim + +@noindent +then instead of getting the first line twice, you get: + +@example +$ @kbd{flex -ofirst-line.c first-line.l} +$ @kbd{gcc -ofirst-line first-line.c -ll} +$ @kbd{./first-line} +input:1: Hello, +input:2: World! +@end example + +Therefore, whenever you change @code{yyin}, you must tell the +Lex-generated scanner to discard its current buffer and switch to the +new one. This depends upon your implementation of Lex; see its +documentation for more. For Flex, it suffices to call +@samp{YY_FLUSH_BUFFER} after each change to @code{yyin}. If your +Flex-generated scanner needs to read from several input streams to +handle features like include files, you might consider using Flex +functions like @samp{yy_switch_to_buffer} that manipulate multiple +input buffers. + +@node Strings are Destroyed +@section Strings are Destroyed + +@display +My parser seems to destroy old strings, or maybe it loses track of +them. Instead of reporting @samp{"foo", "bar"}, it reports +@samp{"bar", "bar"}, or even @samp{"foo\nbar", "bar"}. +@end display + +This error is probably the single most frequent ``bug report'' sent to +Bison lists, but is only concerned with a misunderstanding of the role +of scanner. Consider the following Lex code: + +@verbatim +%{ +#include +char *yylval = NULL; +%} +%% +.* yylval = yytext; return 1; +\n /* IGNORE */ +%% +int +main () +{ + /* Similar to using $1, $2 in a Bison action. */ + char *fst = (yylex (), yylval); + char *snd = (yylex (), yylval); + printf ("\"%s\", \"%s\"\n", fst, snd); + return 0; +} +@end verbatim + +If you compile and run this code, you get: + +@example +$ @kbd{flex -osplit-lines.c split-lines.l} +$ @kbd{gcc -osplit-lines split-lines.c -ll} +$ @kbd{printf 'one\ntwo\n' | ./split-lines} +"one +two", "two" +@end example + +@noindent +this is because @code{yytext} is a buffer provided for @emph{reading} +in the action, but if you want to keep it, you have to duplicate it +(e.g., using @code{strdup}). Note that the output may depend on how +your implementation of Lex handles @code{yytext}. For instance, when +given the Lex compatibility option @option{-l} (which triggers the +option @samp{%array}) Flex generates a different behavior: + +@example +$ @kbd{flex -l -osplit-lines.c split-lines.l} +$ @kbd{gcc -osplit-lines split-lines.c -ll} +$ @kbd{printf 'one\ntwo\n' | ./split-lines} +"two", "two" +@end example + + +@node C++ Parsers +@section C++ Parsers + +@display +How can I generate parsers in C++? +@end display + +We are working on a C++ output for Bison, but unfortunately, for lack +of time, the skeleton is not finished. It is functional, but in +numerous respects, it will require additional work which @emph{might} +break backward compatibility. Since the skeleton for C++ is not +documented, we do not consider ourselves bound to this interface, +nevertheless, as much as possible we will try to keep compatibility. + +Another possibility is to use the regular C parsers, and to compile +them with a C++ compiler. This works properly, provided that you bear +some simple C++ rules in mind, such as not including ``real classes'' +(i.e., structure with constructors) in unions. Therefore, in the +@code{%union}, use pointers to classes, or better yet, a single +pointer type to the root of your lexical/syntactic hierarchy. + + +@node Implementing Loops +@section Implementing Loops + +@display +My simple calculator supports variables, assignments, and functions, +but how can I implement loops? +@end display + +Although very pedagogical, the examples included in the document blur +the distinction to make between the parser---whose job is to recover +the structure of a text and to transmit it to subsequent modules of +the program---and the processing (such as the execution) of this +structure. This works well with so called straight line programs, +i.e., precisely those that have a straightforward execution model: +execute simple instructions one after the others. + +@cindex abstract syntax tree +@cindex @acronym{AST} +If you want a richer model, you will probably need to use the parser +to construct a tree that does represent the structure it has +recovered; this tree is usually called the @dfn{abstract syntax tree}, +or @dfn{@acronym{AST}} for short. Then, walking through this tree, +traversing it in various ways, will enable treatments such as its +execution or its translation, which will result in an interpreter or a +compiler. + +This topic is way beyond the scope of this manual, and the reader is +invited to consult the dedicated literature. + + + @c ================================================= Table of Symbols @node Table of Symbols @@ -6562,8 +6757,8 @@ External variable in which @code{yylex} should place the line and column numbers associated with a token. (In a pure parser, it is a local variable within @code{yyparse}, and its address is passed to @code{yylex}.) You can ignore this variable if you don't use the -@samp{@@} feature in the grammar actions. @xref{Token Positions, -,Textual Positions of Tokens}. +@samp{@@} feature in the grammar actions. @xref{Token Locations, +,Textual Locations of Tokens}. @end deffn @deffn {Variable} yynerrs @@ -6617,13 +6812,11 @@ Bison declaration to assign left associativity to token(s). @xref{Precedence Decl, ,Operator Precedence}. @end deffn -@ifset documentparam @deffn {Directive} %lex-param @{@var{argument-declaration}@} Bison declaration to specifying an additional parameter that @code{yylex} should accept. @xref{Pure Calling,, Calling Conventions for Pure Parsers}. @end deffn -@end ifset @deffn {Directive} %merge Bison declaration to assign a merging function to a rule. If there is a @@ -6651,13 +6844,11 @@ Bison declaration to set the name of the parser file. @xref{Decl Summary}. @end deffn -@ifset documentparam @deffn {Directive} %parse-param @{@var{argument-declaration}@} Bison declaration to specifying an additional parameter that @code{yyparse} should accept. @xref{Parser Function,, The Parser Function @code{yyparse}}. @end deffn -@end ifset @deffn {Directive} %prec Bison declaration to assign a precedence to a specific rule. @@ -6921,3 +7112,33 @@ grammatically indivisible. The piece of text it represents is a token. @printindex cp @bye + +@c LocalWords: texinfo setfilename settitle setchapternewpage finalout +@c LocalWords: ifinfo smallbook shorttitlepage titlepage GPL FIXME iftex +@c LocalWords: akim fn cp syncodeindex vr tp synindex dircategory direntry +@c LocalWords: ifset vskip pt filll insertcopying sp ISBN Etienne Suvasa +@c LocalWords: ifnottex yyparse detailmenu GLR RPN Calc var Decls Rpcalc +@c LocalWords: rpcalc Lexer Gen Comp Expr ltcalc mfcalc Decl Symtab yylex +@c LocalWords: yyerror pxref LR yylval cindex dfn LALR samp gpl BNF xref +@c LocalWords: const int paren ifnotinfo AC noindent emph expr stmt findex +@c LocalWords: glr YYSTYPE TYPENAME prog dprec printf decl init stmtMerge +@c LocalWords: pre STDC GNUC endif yy YY alloca lf stddef stdlib YYDEBUG +@c LocalWords: NUM exp subsubsection kbd Ctrl ctype EOF getchar isdigit +@c LocalWords: ungetc stdin scanf sc calc ulator ls lm cc NEG prec yyerrok +@c LocalWords: longjmp fprintf stderr preg yylloc YYLTYPE cos ln +@c LocalWords: smallexample symrec val tptr FNCT fnctptr func struct sym +@c LocalWords: fnct putsym getsym fname arith fncts atan ptr malloc sizeof +@c LocalWords: strlen strcpy fctn strcmp isalpha symbuf realloc isalnum +@c LocalWords: ptypes itype YYPRINT trigraphs yytname expseq vindex dtype +@c LocalWords: Rhs YYRHSLOC LE nonassoc op deffn typeless typefull yynerrs +@c LocalWords: yychar yydebug msg YYNTOKENS YYNNTS YYNRULES YYNSTATES +@c LocalWords: cparse clex deftypefun NE defmac YYACCEPT YYABORT param +@c LocalWords: strncmp intval tindex lvalp locp llocp typealt YYBACKUP +@c LocalWords: YYEMPTY 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: hexflag STR exdent itemset asis DYYDEBUG YYFPRINTF args +@c LocalWords: YYPRINTF infile ypp yxx outfile itemx vcg 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