From 354303787cfbdc0839e6d55c9956c5e664aa625a Mon Sep 17 00:00:00 2001 From: "Joel E. Denny" Date: Sat, 8 Jan 2011 13:52:05 -0500 Subject: [PATCH] doc: don't use @acronym. Lately, many GNU packages are dropping it. See . * doc/bison.texinfo: Remove all uses. (cherry picked from commit 8a4281b987577d911e418e8a37aef0c9c7121bf8) Conflicts: doc/bison.texinfo --- ChangeLog | 7 + doc/bison.texinfo | 460 +++++++++++++++++++++++----------------------- 2 files changed, 237 insertions(+), 230 deletions(-) diff --git a/ChangeLog b/ChangeLog index a7d8a764..26610a7c 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,10 @@ +2011-01-08 Joel E. Denny + + doc: don't use @acronym. + Lately, many GNU packages are dropping it. See + . + * doc/bison.texinfo: Remove all uses. + 2011-01-05 Alex Rozenman Do not allow identifiers that start with a negative number. diff --git a/doc/bison.texinfo b/doc/bison.texinfo index 4ecdb472..dfd3a140 100644 --- a/doc/bison.texinfo +++ b/doc/bison.texinfo @@ -30,31 +30,31 @@ @copying -This manual (@value{UPDATED}) is for @acronym{GNU} Bison (version -@value{VERSION}), the @acronym{GNU} parser generator. +This manual (@value{UPDATED}) is for GNU Bison (version +@value{VERSION}), the GNU parser generator. Copyright @copyright{} 1988-1993, 1995, 1998-2011 Free Software Foundation, Inc. @quotation Permission is granted to copy, distribute and/or modify this document -under the terms of the @acronym{GNU} Free Documentation License, +under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, with the Front-Cover texts -being ``A @acronym{GNU} Manual,'' and with the Back-Cover Texts as in +being ``A GNU Manual,'' and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled -``@acronym{GNU} Free Documentation License.'' +``GNU Free Documentation License.'' (a) The FSF's Back-Cover Text is: ``You have the freedom to copy and -modify this @acronym{GNU} manual. Buying copies from the @acronym{FSF} -supports it in developing @acronym{GNU} and promoting software +modify this GNU manual. Buying copies from the FSF +supports it in developing GNU and promoting software freedom.'' @end quotation @end copying @dircategory Software development @direntry -* bison: (bison). @acronym{GNU} parser generator (Yacc replacement). +* bison: (bison). GNU parser generator (Yacc replacement). @end direntry @titlepage @@ -72,7 +72,7 @@ Published by the Free Software Foundation @* 51 Franklin Street, Fifth Floor @* Boston, MA 02110-1301 USA @* Printed copies are available from the Free Software Foundation.@* -@acronym{ISBN} 1-882114-44-2 +ISBN 1-882114-44-2 @sp 2 Cover art by Etienne Suvasa. @end titlepage @@ -88,7 +88,7 @@ Cover art by Etienne Suvasa. @menu * Introduction:: * Conditions:: -* Copying:: The @acronym{GNU} General Public License says +* Copying:: The GNU General Public License says how you can copy and share Bison. Tutorial sections: @@ -130,12 +130,12 @@ The Concepts of Bison * Stages:: Stages in writing and running Bison grammars. * Grammar Layout:: Overall structure of a Bison grammar file. -Writing @acronym{GLR} Parsers +Writing GLR Parsers -* Simple GLR Parsers:: Using @acronym{GLR} parsers on unambiguous grammars. -* Merging GLR Parses:: Using @acronym{GLR} parsers to resolve ambiguities. +* Simple GLR Parsers:: Using GLR parsers on unambiguous grammars. +* Merging GLR Parses:: Using GLR parsers to resolve ambiguities. * GLR Semantic Actions:: Deferred semantic actions have special concerns. -* Compiler Requirements:: @acronym{GLR} parsers require a modern C compiler. +* Compiler Requirements:: GLR parsers require a modern C compiler. Examples @@ -331,7 +331,7 @@ Frequently Asked Questions * Strings are Destroyed:: @code{yylval} Loses Track of Strings * Implementing Gotos/Loops:: Control Flow in the Calculator * Multiple start-symbols:: Factoring closely related grammars -* Secure? Conform?:: Is Bison @acronym{POSIX} safe? +* Secure? Conform?:: Is Bison POSIX safe? * I can't build Bison:: Troubleshooting * Where can I find help?:: Troubleshouting * Bug Reports:: Troublereporting @@ -351,9 +351,9 @@ Copying This Manual @cindex introduction @dfn{Bison} is a general-purpose parser generator that converts an -annotated context-free grammar into a deterministic @acronym{LR} or -generalized @acronym{LR} (@acronym{GLR}) parser employing -@acronym{LALR}(1), @acronym{IELR}(1), or canonical @acronym{LR}(1) +annotated context-free grammar into a deterministic LR or +generalized LR (GLR) parser employing +LALR(1), IELR(1), or canonical LR(1) parser tables. Once you are proficient with Bison, you can use it to develop a wide range of language parsers, from those used in simple desk calculators to @@ -380,11 +380,11 @@ This edition corresponds to version @value{VERSION} of Bison. The distribution terms for Bison-generated parsers permit using the parsers in nonfree programs. Before Bison version 2.2, these extra -permissions applied only when Bison was generating @acronym{LALR}(1) +permissions applied only when Bison was generating LALR(1) parsers in C@. And before Bison version 1.24, Bison-generated parsers could be used only in programs that were free software. -The other @acronym{GNU} programming tools, such as the @acronym{GNU} C +The other GNU programming tools, such as the GNU C compiler, have never had such a requirement. They could always be used for nonfree software. The reason Bison was different was not due to a special @@ -395,7 +395,7 @@ The output of the Bison utility---the Bison parser file---contains a verbatim copy of a sizable piece of Bison, which is the code for the parser's implementation. (The actions from your grammar are inserted into this implementation at one point, but most of the rest of the -implementation is not changed.) When we applied the @acronym{GPL} +implementation is not changed.) When we applied the GPL terms to the skeleton code for the parser's implementation, the effect was to restrict the use of Bison output to free software. @@ -404,7 +404,7 @@ make software proprietary. @strong{Software should be free.} But we concluded that limiting Bison's use to free software was doing little to encourage people to make other software free. So we decided to make the practical conditions for using Bison match the practical conditions for -using the other @acronym{GNU} tools. +using the other GNU tools. This exception applies when Bison is generating code for a parser. You can tell whether the exception applies to a Bison output file by @@ -454,36 +454,36 @@ can be made of a minus sign and another expression''. Another would be, recursive, but there must be at least one rule which leads out of the recursion. -@cindex @acronym{BNF} +@cindex BNF @cindex Backus-Naur form The most common formal system for presenting such rules for humans to read -is @dfn{Backus-Naur Form} or ``@acronym{BNF}'', which was developed in +is @dfn{Backus-Naur Form} or ``BNF'', which was developed in order to specify the language Algol 60. Any grammar expressed in -@acronym{BNF} is a context-free grammar. The input to Bison is -essentially machine-readable @acronym{BNF}. +BNF is a context-free grammar. The input to Bison is +essentially machine-readable BNF. -@cindex @acronym{LALR}(1) grammars -@cindex @acronym{IELR}(1) grammars -@cindex @acronym{LR}(1) grammars +@cindex LALR(1) grammars +@cindex IELR(1) grammars +@cindex LR(1) grammars There are various important subclasses of context-free grammars. Although it can handle almost all context-free grammars, Bison is -optimized for what are called @acronym{LR}(1) grammars. +optimized for what are called LR(1) grammars. In brief, in these grammars, it must be possible to tell how to parse any portion of an input string with just a single token of lookahead. For historical reasons, Bison by default is limited by the additional -restrictions of @acronym{LALR}(1), which is hard to explain simply. +restrictions of LALR(1), which is hard to explain simply. @xref{Mystery Conflicts, ,Mysterious Reduce/Reduce Conflicts}, for more information on this. As an experimental feature, you can escape these additional restrictions by -requesting @acronym{IELR}(1) or canonical @acronym{LR}(1) parser tables. +requesting IELR(1) or canonical LR(1) parser tables. @xref{Decl Summary,,lr.type}, to learn how. -@cindex @acronym{GLR} parsing -@cindex generalized @acronym{LR} (@acronym{GLR}) parsing +@cindex GLR parsing +@cindex generalized LR (GLR) parsing @cindex ambiguous grammars @cindex nondeterministic parsing -Parsers for @acronym{LR}(1) grammars are @dfn{deterministic}, meaning +Parsers for LR(1) grammars are @dfn{deterministic}, meaning roughly that the next grammar rule to apply at any point in the input is uniquely determined by the preceding input and a fixed, finite portion (called a @dfn{lookahead}) of the remaining input. A context-free @@ -492,8 +492,8 @@ apply the grammar rules to get the same inputs. Even unambiguous grammars can be @dfn{nondeterministic}, meaning that no fixed lookahead always suffices to determine the next grammar rule to apply. With the proper declarations, Bison is also able to parse these more -general context-free grammars, using a technique known as @acronym{GLR} -parsing (for Generalized @acronym{LR}). Bison's @acronym{GLR} parsers +general context-free grammars, using a technique known as GLR +parsing (for Generalized LR). Bison's GLR parsers are able to handle any context-free grammar for which the number of possible parses of any given string is finite. @@ -704,16 +704,16 @@ The action says how to produce the semantic value of the sum expression from the values of the two subexpressions. @node GLR Parsers -@section Writing @acronym{GLR} Parsers -@cindex @acronym{GLR} parsing -@cindex generalized @acronym{LR} (@acronym{GLR}) parsing +@section Writing GLR Parsers +@cindex GLR parsing +@cindex generalized LR (GLR) parsing @findex %glr-parser @cindex conflicts @cindex shift/reduce conflicts @cindex reduce/reduce conflicts In some grammars, Bison's deterministic -@acronym{LR}(1) parsing algorithm cannot decide whether to apply a +LR(1) parsing algorithm cannot decide whether to apply a certain grammar rule at a given point. That is, it may not be able to decide (on the basis of the input read so far) which of two possible reductions (applications of a grammar rule) applies, or whether to apply @@ -722,15 +722,15 @@ input. These are known respectively as @dfn{reduce/reduce} conflicts (@pxref{Reduce/Reduce}), and @dfn{shift/reduce} conflicts (@pxref{Shift/Reduce}). -To use a grammar that is not easily modified to be @acronym{LR}(1), a +To use a grammar that is not easily modified to be LR(1), a more general parsing algorithm is sometimes necessary. If you include @code{%glr-parser} among the Bison declarations in your file -(@pxref{Grammar Outline}), the result is a Generalized @acronym{LR} -(@acronym{GLR}) parser. These parsers handle Bison grammars that +(@pxref{Grammar Outline}), the result is a Generalized LR +(GLR) parser. These parsers handle Bison grammars that contain no unresolved conflicts (i.e., after applying precedence declarations) identically to deterministic parsers. However, when faced with unresolved shift/reduce and reduce/reduce conflicts, -@acronym{GLR} parsers use the simple expedient of doing both, +GLR parsers use the simple expedient of doing both, effectively cloning the parser to follow both possibilities. Each of the resulting parsers can again split, so that at any given time, there can be any number of possible parses being explored. The parsers @@ -753,24 +753,24 @@ user-defined function on the resulting values to produce an arbitrary merged result. @menu -* Simple GLR Parsers:: Using @acronym{GLR} parsers on unambiguous grammars. -* Merging GLR Parses:: Using @acronym{GLR} parsers to resolve ambiguities. +* Simple GLR Parsers:: Using GLR parsers on unambiguous grammars. +* Merging GLR Parses:: Using GLR parsers to resolve ambiguities. * GLR Semantic Actions:: Deferred semantic actions have special concerns. -* Compiler Requirements:: @acronym{GLR} parsers require a modern C compiler. +* Compiler Requirements:: GLR parsers require a modern C compiler. @end menu @node Simple GLR Parsers -@subsection Using @acronym{GLR} on Unambiguous Grammars -@cindex @acronym{GLR} parsing, unambiguous grammars -@cindex generalized @acronym{LR} (@acronym{GLR}) parsing, unambiguous grammars +@subsection Using GLR on Unambiguous Grammars +@cindex GLR parsing, unambiguous grammars +@cindex generalized LR (GLR) parsing, unambiguous grammars @findex %glr-parser @findex %expect-rr @cindex conflicts @cindex reduce/reduce conflicts @cindex shift/reduce conflicts -In the simplest cases, you can use the @acronym{GLR} algorithm -to parse grammars that are unambiguous but fail to be @acronym{LR}(1). +In the simplest cases, you can use the GLR algorithm +to parse grammars that are unambiguous but fail to be LR(1). Such grammars typically require more than one symbol of lookahead. Consider a problem that @@ -785,7 +785,7 @@ type enum = (a, b, c); @noindent The original language standard allows only numeric literals and constant identifiers for the subrange bounds (@samp{lo} -and @samp{hi}), but Extended Pascal (@acronym{ISO}/@acronym{IEC} +and @samp{hi}), but Extended Pascal (ISO/IEC 10206) and many other Pascal implementations allow arbitrary expressions there. This gives rise to the following situation, containing a superfluous pair of @@ -808,7 +808,7 @@ type enum = (a); valid, and more-complicated cases can come up in practical programs.) These two declarations look identical until the @samp{..} token. -With normal @acronym{LR}(1) one-token lookahead it is not +With normal LR(1) one-token lookahead it is not possible to decide between the two forms when the identifier @samp{a} is parsed. It is, however, desirable for a parser to decide this, since in the latter case @@ -831,8 +831,8 @@ value of @samp{a} from the outer scope. So this approach cannot work. A simple solution to this problem is to declare the parser to -use the @acronym{GLR} algorithm. -When the @acronym{GLR} parser reaches the critical state, it +use the GLR algorithm. +When the GLR parser reaches the critical state, it merely splits into two branches and pursues both syntax rules simultaneously. Sooner or later, one of them runs into a parsing error. If there is a @samp{..} token before the next @@ -847,11 +847,11 @@ reports a syntax error as usual. The effect of all this is that the parser seems to ``guess'' the correct branch to take, or in other words, it seems to use more -lookahead than the underlying @acronym{LR}(1) algorithm actually allows -for. In this example, @acronym{LR}(2) would suffice, but also some cases -that are not @acronym{LR}(@math{k}) for any @math{k} can be handled this way. +lookahead than the underlying LR(1) algorithm actually allows +for. In this example, LR(2) would suffice, but also some cases +that are not LR(@math{k}) for any @math{k} can be handled this way. -In general, a @acronym{GLR} parser can take quadratic or cubic worst-case time, +In general, a GLR parser can take quadratic or cubic worst-case time, and the current Bison parser even takes exponential time and space for some grammars. In practice, this rarely happens, and for many grammars it is possible to prove that it cannot happen. @@ -902,7 +902,7 @@ expr : '(' expr ')' @end group @end example -When used as a normal @acronym{LR}(1) grammar, Bison correctly complains +When used as a normal LR(1) grammar, Bison correctly complains about one reduce/reduce conflict. In the conflicting situation the parser chooses one of the alternatives, arbitrarily the one declared first. Therefore the following correct input is not @@ -912,7 +912,7 @@ recognized: type t = (a) .. b; @end example -The parser can be turned into a @acronym{GLR} parser, while also telling Bison +The parser can be turned into a GLR parser, while also telling Bison to be silent about the one known reduce/reduce conflict, by adding these two declarations to the Bison input file (before the first @samp{%%}): @@ -928,18 +928,18 @@ parser recognizes all valid declarations, according to the limited syntax above, transparently. In fact, the user does not even notice when the parser splits. -So here we have a case where we can use the benefits of @acronym{GLR}, +So here we have a case where we can use the benefits of GLR, almost without disadvantages. Even in simple cases like this, however, there are at least two potential problems to beware. First, always -analyze the conflicts reported by Bison to make sure that @acronym{GLR} -splitting is only done where it is intended. A @acronym{GLR} parser +analyze the conflicts reported by Bison to make sure that GLR +splitting is only done where it is intended. A GLR parser splitting inadvertently may cause problems less obvious than an -@acronym{LR} parser statically choosing the wrong alternative in a +LR parser statically choosing the wrong alternative in a conflict. Second, consider interactions with the lexer (@pxref{Semantic Tokens}) with great care. Since a split parser consumes tokens without performing any actions during the split, the lexer cannot obtain information via parser actions. Some cases of lexer interactions can be -eliminated by using @acronym{GLR} to shift the complications from the +eliminated by using GLR to shift the complications from the lexer to the parser. You must check the remaining cases for correctness. @@ -951,9 +951,9 @@ the type declaration is completed, it actually makes no difference since they cannot be used within the same enumerated type declaration. @node Merging GLR Parses -@subsection Using @acronym{GLR} to Resolve Ambiguities -@cindex @acronym{GLR} parsing, ambiguous grammars -@cindex generalized @acronym{LR} (@acronym{GLR}) parsing, ambiguous grammars +@subsection Using GLR to Resolve Ambiguities +@cindex GLR parsing, ambiguous grammars +@cindex generalized LR (GLR) parsing, ambiguous grammars @findex %dprec @findex %merge @cindex conflicts @@ -1019,7 +1019,7 @@ parses as either an @code{expr} or a @code{stmt} Bison detects this as a reduce/reduce conflict between the rules @code{expr : ID} and @code{declarator : ID}, which it cannot resolve at the time it encounters @code{x} in the example above. Since this is a -@acronym{GLR} parser, it therefore splits the problem into two parses, one for +GLR parser, it therefore splits the problem into two parses, one for each choice of resolving the reduce/reduce conflict. Unlike the example from the previous section (@pxref{Simple GLR Parsers}), however, neither of these parses ``dies,'' because the grammar as it stands is @@ -1028,7 +1028,7 @@ the other reduces @code{stmt : decl}, after which both parsers are in an identical state: they've seen @samp{prog stmt} and have the same unprocessed input remaining. We say that these parses have @dfn{merged.} -At this point, the @acronym{GLR} parser requires a specification in the +At this point, the GLR parser requires a specification in the grammar of how to choose between the competing parses. In the example above, the two @code{%dprec} declarations specify that Bison is to give precedence @@ -1048,7 +1048,7 @@ T (x) + y; @end example @noindent -This is another example of using @acronym{GLR} to parse an unambiguous +This is another example of using GLR to parse an unambiguous construct, as shown in the previous section (@pxref{Simple GLR Parsers}). Here, there is no ambiguity (this cannot be parsed as a declaration). However, at the time the Bison parser encounters @code{x}, it does not @@ -1119,14 +1119,14 @@ the offending merge. By definition, a deferred semantic action is not performed at the same time as the associated reduction. This raises caveats for several Bison features you might use in a semantic -action in a @acronym{GLR} parser. +action in a GLR parser. @vindex yychar -@cindex @acronym{GLR} parsers and @code{yychar} +@cindex GLR parsers and @code{yychar} @vindex yylval -@cindex @acronym{GLR} parsers and @code{yylval} +@cindex GLR parsers and @code{yylval} @vindex yylloc -@cindex @acronym{GLR} parsers and @code{yylloc} +@cindex GLR parsers and @code{yylloc} In any semantic action, you can examine @code{yychar} to determine the type of the lookahead token present at the time of the associated reduction. After checking that @code{yychar} is not set to @code{YYEMPTY} or @code{YYEOF}, @@ -1137,7 +1137,7 @@ influence syntax analysis. @xref{Lookahead, ,Lookahead Tokens}. @findex yyclearin -@cindex @acronym{GLR} parsers and @code{yyclearin} +@cindex GLR parsers and @code{yyclearin} In a deferred semantic action, it's too late to influence syntax analysis. In this case, @code{yychar}, @code{yylval}, and @code{yylloc} are set to shallow copies of the values they had at the time of the associated reduction. @@ -1149,24 +1149,24 @@ to invoke @code{yyclearin} (@pxref{Action Features}) or to attempt to free memory referenced by @code{yylval}. @findex YYERROR -@cindex @acronym{GLR} parsers and @code{YYERROR} +@cindex GLR parsers and @code{YYERROR} Another Bison feature requiring special consideration is @code{YYERROR} (@pxref{Action Features}), which you can invoke in a semantic action to initiate error recovery. -During deterministic @acronym{GLR} operation, the effect of @code{YYERROR} is +During deterministic GLR operation, the effect of @code{YYERROR} is the same as its effect in a deterministic parser. In a deferred semantic action, its effect is undefined. @c The effect is probably a syntax error at the split point. Also, see @ref{Location Default Action, ,Default Action for Locations}, which -describes a special usage of @code{YYLLOC_DEFAULT} in @acronym{GLR} parsers. +describes a special usage of @code{YYLLOC_DEFAULT} in GLR parsers. @node Compiler Requirements -@subsection Considerations when Compiling @acronym{GLR} Parsers +@subsection Considerations when Compiling GLR Parsers @cindex @code{inline} -@cindex @acronym{GLR} parsers and @code{inline} +@cindex GLR parsers and @code{inline} -The @acronym{GLR} parsers require a compiler for @acronym{ISO} C89 or +The GLR parsers require a compiler for ISO C89 or later. In addition, they use the @code{inline} keyword, which is not C89, but is C99 and is a common extension in pre-C99 compilers. It is up to the user of these parsers to handle @@ -1269,7 +1269,7 @@ meanings. In some cases the Bison parser file includes system headers, and in those cases your code should respect the identifiers reserved by those -headers. On some non-@acronym{GNU} hosts, @code{}, @code{}, +headers. On some non-GNU hosts, @code{}, @code{}, @code{}, and @code{} are included as needed to declare memory allocators and related types. @code{} is included if message translation is in use @@ -1647,7 +1647,7 @@ or sequences of characters into tokens. The Bison parser gets its tokens by calling the lexical analyzer. @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}. -Only a simple lexical analyzer is needed for the @acronym{RPN} +Only a simple lexical analyzer is needed for the RPN calculator. This lexical analyzer skips blanks and tabs, then reads in numbers as @code{double} and returns them as @code{NUM} tokens. Any other character @@ -2633,7 +2633,7 @@ appropriate delimiters: @end example Comments enclosed in @samp{/* @dots{} */} may appear in any of the sections. -As a @acronym{GNU} extension, @samp{//} introduces a comment that +As a GNU extension, @samp{//} introduces a comment that continues until end of line. @menu @@ -3051,7 +3051,7 @@ By convention, it should be all lower case. Symbol names can contain letters, underscores, periods, dashes, and (not at the beginning) digits. Dashes in symbol names are a GNU -extension, incompatible with @acronym{POSIX} Yacc. Terminal symbols +extension, incompatible with POSIX Yacc. Terminal symbols that contain periods or dashes make little sense: since they are not valid symbols (in most programming languages) they are not exported as token names. @@ -3158,14 +3158,14 @@ characters in the following C-language string: The @code{yylex} function and Bison must use a consistent character set and encoding for character tokens. For example, if you run Bison in an -@acronym{ASCII} environment, but then compile and run the resulting +ASCII environment, but then compile and run the resulting program in an environment that uses an incompatible character set like -@acronym{EBCDIC}, the resulting program may not work because the tables -generated by Bison will assume @acronym{ASCII} numeric values for +EBCDIC, the resulting program may not work because the tables +generated by Bison will assume ASCII numeric values for character tokens. It is standard practice for software distributions to contain C source files that were generated by Bison in an -@acronym{ASCII} environment, so installers on platforms that are -incompatible with @acronym{ASCII} must rebuild those files before +ASCII environment, so installers on platforms that are +incompatible with ASCII must rebuild those files before compiling them. The symbol @code{error} is a terminal symbol reserved for error recovery @@ -3378,7 +3378,7 @@ the numbers associated with @var{x} and @var{y}. In a simple program it may be sufficient to use the same data type for the semantic values of all language constructs. This was true in the -@acronym{RPN} and infix calculator examples (@pxref{RPN Calc, ,Reverse Polish +RPN and infix calculator examples (@pxref{RPN Calc, ,Reverse Polish Notation Calculator}). Bison normally uses the type @code{int} for semantic values if your @@ -4004,7 +4004,7 @@ This location is stored in @code{yylloc}. @node Location Default Action @subsection Default Action for Locations @vindex YYLLOC_DEFAULT -@cindex @acronym{GLR} parsers and @code{YYLLOC_DEFAULT} +@cindex GLR parsers and @code{YYLLOC_DEFAULT} Actually, actions are not the best place to compute locations. Since locations are much more general than semantic values, there is room in @@ -4012,7 +4012,7 @@ the output parser to redefine the default action to take for each rule. The @code{YYLLOC_DEFAULT} macro is invoked each time a rule is matched, before the associated action is run. It is also invoked while processing a syntax error, to compute the error's location. -Before reporting an unresolvable syntactic ambiguity, a @acronym{GLR} +Before reporting an unresolvable syntactic ambiguity, a GLR parser invokes @code{YYLLOC_DEFAULT} recursively to compute the location of that ambiguity. @@ -4024,7 +4024,7 @@ the location of the grouping (the result of the computation). When a rule is matched, the second parameter identifies locations of all right hand side elements of the rule being matched, and the third parameter is the size of the rule's right hand side. -When a @acronym{GLR} parser reports an ambiguity, which of multiple candidate +When a GLR parser reports an ambiguity, which of multiple candidate right hand sides it passes to @code{YYLLOC_DEFAULT} is undefined. When processing a syntax error, the second parameter identifies locations of the symbols that were discarded during error processing, and the third @@ -4303,7 +4303,7 @@ This says that the two alternative types are @code{double} and @code{symrec in the @code{%token} and @code{%type} declarations to pick one of the types for a terminal or nonterminal symbol (@pxref{Type Decl, ,Nonterminal Symbols}). -As an extension to @acronym{POSIX}, a tag is allowed after the +As an extension to POSIX, a tag is allowed after the @code{union}. For example: @example @@ -4320,7 +4320,7 @@ 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}. -As another extension to @acronym{POSIX}, you may specify multiple +As another extension to POSIX, you may specify multiple @code{%union} declarations; their contents are concatenated. However, only the first @code{%union} declaration can specify a tag. @@ -4585,11 +4585,11 @@ from @var{n}, or if there are any reduce/reduce conflicts. For deterministic parsers, reduce/reduce conflicts are more serious, and should be eliminated entirely. Bison will always report -reduce/reduce conflicts for these parsers. With @acronym{GLR} +reduce/reduce conflicts for these parsers. With GLR parsers, however, both kinds of conflicts are routine; otherwise, -there would be no need to use @acronym{GLR} parsing. Therefore, it is +there would be no need to use GLR parsing. Therefore, it is also possible to specify an expected number of reduce/reduce conflicts -in @acronym{GLR} parsers, using the declaration: +in GLR parsers, using the declaration: @example %expect-rr @var{n} @@ -4610,7 +4610,7 @@ go back to the beginning. @item Add an @code{%expect} declaration, copying the number @var{n} from the -number which Bison printed. With @acronym{GLR} parsers, add an +number which Bison printed. With GLR parsers, add an @code{%expect-rr} declaration as well. @end itemize @@ -5027,7 +5027,7 @@ More user feedback will help to stabilize it.) @findex %define lr.default-reductions @cindex delayed syntax errors @cindex syntax errors delayed -@cindex @acronym{LAC} +@cindex LAC @findex %nonassoc @itemize @bullet @@ -5052,12 +5052,12 @@ The disadvantage is that, when the generated parser encounters a syntactically unacceptable token, the parser might then perform unnecessary default reductions before it can detect the syntax error. Such delayed syntax error detection is usually inherent in -@acronym{LALR} and @acronym{IELR} parser tables anyway due to -@acronym{LR} state merging (@pxref{Decl Summary,,lr.type}). +LALR and IELR parser tables anyway due to +LR state merging (@pxref{Decl Summary,,lr.type}). Furthermore, the use of @code{%nonassoc} can contribute to delayed -syntax error detection even in the case of canonical @acronym{LR}. +syntax error detection even in the case of canonical LR. As an experimental feature, delayed syntax error detection can be -overcome in all cases by enabling @acronym{LAC} (@pxref{Decl +overcome in all cases by enabling LAC (@pxref{Decl Summary,,parse.lac}, for details, including a discussion of the effects of delayed syntax error detection). @@ -5070,7 +5070,7 @@ However, the parser recognizes the ability to ignore the lookahead token in this way only when such a reduction is encoded as a default reduction. Thus, if default reductions are permitted only in consistent states, -then a canonical @acronym{LR} parser that does not employ +then a canonical LR parser that does not employ @code{%nonassoc} detects a syntax error as soon as it @emph{needs} the syntactically unacceptable token from the scanner. @@ -5078,7 +5078,7 @@ syntactically unacceptable token from the scanner. @cindex accepting state In the accepting state, the default reduction is actually the accept action. -In this case, a canonical @acronym{LR} parser that does not employ +In this case, a canonical LR parser that does not employ @code{%nonassoc} detects a syntax error as soon as it @emph{reaches} the syntactically unacceptable token in the input. That is, it does not perform any extra reductions. @@ -5140,85 +5140,85 @@ However, Bison does not compute which goto actions are useless. @item lr.type @findex %define lr.type -@cindex @acronym{LALR} -@cindex @acronym{IELR} -@cindex @acronym{LR} +@cindex LALR +@cindex IELR +@cindex LR @itemize @bullet @item Language(s): all @item Purpose: Specify the type of parser tables within the -@acronym{LR}(1) family. +LR(1) family. (This feature is experimental. More user feedback will help to stabilize it.) @item Accepted Values: @itemize @item @code{lalr}. -While Bison generates @acronym{LALR} parser tables by default for -historical reasons, @acronym{IELR} or canonical @acronym{LR} is almost +While Bison generates LALR parser tables by default for +historical reasons, IELR or canonical LR is almost always preferable for deterministic parsers. -The trouble is that @acronym{LALR} parser tables can suffer from +The trouble is that LALR parser tables can suffer from mysterious conflicts and thus may not accept the full set of sentences -that @acronym{IELR} and canonical @acronym{LR} accept. +that IELR and canonical LR accept. @xref{Mystery Conflicts}, for details. -However, there are at least two scenarios where @acronym{LALR} may be +However, there are at least two scenarios where LALR may be worthwhile: @itemize -@cindex @acronym{GLR} with @acronym{LALR} -@item When employing @acronym{GLR} parsers (@pxref{GLR Parsers}), if you +@cindex GLR with LALR +@item When employing GLR parsers (@pxref{GLR Parsers}), if you do not resolve any conflicts statically (for example, with @code{%left} or @code{%prec}), then the parser explores all potential parses of any given input. -In this case, the use of @acronym{LALR} parser tables is guaranteed not +In this case, the use of LALR parser tables is guaranteed not to alter the language accepted by the parser. -@acronym{LALR} parser tables are the smallest parser tables Bison can +LALR parser tables are the smallest parser tables Bison can currently generate, so they may be preferable. Nevertheless, once you begin to resolve conflicts statically, -@acronym{GLR} begins to behave more like a deterministic parser, and so -@acronym{IELR} and canonical @acronym{LR} can be helpful to avoid -@acronym{LALR}'s mysterious behavior. +GLR begins to behave more like a deterministic parser, and so +IELR and canonical LR can be helpful to avoid +LALR's mysterious behavior. @item Occasionally during development, an especially malformed grammar -with a major recurring flaw may severely impede the @acronym{IELR} or -canonical @acronym{LR} parser table generation algorithm. -@acronym{LALR} can be a quick way to generate parser tables in order to +with a major recurring flaw may severely impede the IELR or +canonical LR parser table generation algorithm. +LALR can be a quick way to generate parser tables in order to investigate such problems while ignoring the more subtle differences -from @acronym{IELR} and canonical @acronym{LR}. +from IELR and canonical LR. @end itemize @item @code{ielr}. -@acronym{IELR} is a minimal @acronym{LR} algorithm. -That is, given any grammar (@acronym{LR} or non-@acronym{LR}), -@acronym{IELR} and canonical @acronym{LR} always accept exactly the same +IELR is a minimal LR algorithm. +That is, given any grammar (LR or non-LR), +IELR and canonical LR always accept exactly the same set of sentences. -However, as for @acronym{LALR}, the number of parser states is often an -order of magnitude less for @acronym{IELR} than for canonical -@acronym{LR}. -More importantly, because canonical @acronym{LR}'s extra parser states -may contain duplicate conflicts in the case of non-@acronym{LR} -grammars, the number of conflicts for @acronym{IELR} is often an order +However, as for LALR, the number of parser states is often an +order of magnitude less for IELR than for canonical +LR. +More importantly, because canonical LR's extra parser states +may contain duplicate conflicts in the case of non-LR +grammars, the number of conflicts for IELR is often an order of magnitude less as well. This can significantly reduce the complexity of developing of a grammar. @item @code{canonical-lr}. @cindex delayed syntax errors @cindex syntax errors delayed -@cindex @acronym{LAC} +@cindex LAC @findex %nonassoc -While inefficient, canonical @acronym{LR} parser tables can be an +While inefficient, canonical LR parser tables can be an interesting means to explore a grammar because they have a property that -@acronym{IELR} and @acronym{LALR} tables do not. +IELR and LALR tables do not. That is, if @code{%nonassoc} is not used and default reductions are left disabled (@pxref{Decl Summary,,lr.default-reductions}), then, for every -left context of every canonical @acronym{LR} state, the set of tokens +left context of every canonical LR state, the set of tokens accepted by that state is guaranteed to be the exact set of tokens that is syntactically acceptable in that left context. -It might then seem that an advantage of canonical @acronym{LR} parsers +It might then seem that an advantage of canonical LR parsers in production is that, under the above constraints, they are guaranteed to detect a syntax error as soon as possible without performing any unnecessary reductions. -However, @acronym{IELR} parsers using @acronym{LAC} (@pxref{Decl +However, IELR parsers using LAC (@pxref{Decl Summary,,parse.lac}) are also able to achieve this behavior without sacrificing @code{%nonassoc} or default reductions. @end itemize @@ -5281,16 +5281,16 @@ The parser namespace is @code{foo} and @code{yylex} is referenced as @c ================================================== parse.lac @item parse.lac @findex %define parse.lac -@cindex @acronym{LAC} +@cindex LAC @cindex lookahead correction @itemize @item Languages(s): C -@item Purpose: Enable @acronym{LAC} (lookahead correction) to improve +@item Purpose: Enable LAC (lookahead correction) to improve syntax error handling. -Canonical @acronym{LR}, @acronym{IELR}, and @acronym{LALR} can suffer +Canonical LR, IELR, and LALR can suffer from a couple of problems upon encountering a syntax error. First, the parser might perform additional parser stack reductions before discovering the syntax error. Such reductions perform user semantic @@ -5303,13 +5303,13 @@ error message can both contain invalid tokens and omit valid tokens. The culprits for the above problems are @code{%nonassoc}, default reductions in inconsistent states, and parser state merging. Thus, -@acronym{IELR} and @acronym{LALR} suffer the most. Canonical -@acronym{LR} can suffer only if @code{%nonassoc} is used or if default +IELR and LALR suffer the most. Canonical +LR can suffer only if @code{%nonassoc} is used or if default reductions are enabled for inconsistent states. -@acronym{LAC} is a new mechanism within the parsing algorithm that -completely solves these problems for canonical @acronym{LR}, -@acronym{IELR}, and @acronym{LALR} without sacrificing @code{%nonassoc}, +LAC is a new mechanism within the parsing algorithm that +completely solves these problems for canonical LR, +IELR, and LALR without sacrificing @code{%nonassoc}, default reductions, or state mering. Conceptually, the mechanism is straight-forward. Whenever the parser fetches a new token from the scanner so that it can determine the next parser action, it immediately @@ -5323,7 +5323,7 @@ error messages are enabled, the parser must then discover the list of expected tokens, so it performs a separate exploratory parse for each token in the grammar. -There is one subtlety about the use of @acronym{LAC}. That is, when in +There is one subtlety about the use of LAC. That is, when in a consistent parser state with a default reduction, the parser will not attempt to fetch a token from the scanner because no lookahead is needed to determine the next parser action. Thus, whether default reductions @@ -5334,16 +5334,16 @@ eventually @emph{needs} that token as a lookahead. The latter behavior is probably more intuitive, so Bison currently provides no way to achieve the former behavior while default reductions are fully enabled. -Thus, when @acronym{LAC} is in use, for some fixed decision of whether +Thus, when LAC is in use, for some fixed decision of whether to enable default reductions in consistent states, canonical -@acronym{LR} and @acronym{IELR} behave exactly the same for both +LR and IELR behave exactly the same for both syntactically acceptable and syntactically unacceptable input. While -@acronym{LALR} still does not support the full language-recognition -power of canonical @acronym{LR} and @acronym{IELR}, @acronym{LAC} at -least enables @acronym{LALR}'s syntax error handling to correctly -reflect @acronym{LALR}'s language-recognition power. +LALR still does not support the full language-recognition +power of canonical LR and IELR, LAC at +least enables LALR's syntax error handling to correctly +reflect LALR's language-recognition power. -Because @acronym{LAC} requires many parse actions to be performed twice, +Because LAC requires many parse actions to be performed twice, it can have a performance penalty. However, not all parse actions must be performed twice. Specifically, during a series of default reductions in consistent states and shift actions, the parser never has to initiate @@ -5353,7 +5353,7 @@ scanner, and the user's semantic actions, but none of these are performed during the exploratory parse. Finally, the base of the temporary stack used during an exploratory parse is a pointer into the normal parser state stack so that the stack is never physically copied. -In our experience, the performance penalty of @acronym{LAC} has proven +In our experience, the performance penalty of LAC has proven insignificant for practical grammars. @item Accepted Values: @code{none}, @code{full} @@ -6052,7 +6052,7 @@ immediately return 1. Obviously, in location tracking pure parsers, @code{yyerror} should have an access to the current location. -This is indeed the case for the @acronym{GLR} +This is indeed the case for the GLR parsers, but not for the Yacc parser, for historical reasons. I.e., if @samp{%locations %define api.pure} is passed then the prototypes for @code{yyerror} are: @@ -6069,7 +6069,7 @@ void yyerror (int *nastiness, char const *msg); /* Yacc parsers. */ void yyerror (int *nastiness, char const *msg); /* GLR parsers. */ @end example -Finally, @acronym{GLR} and Yacc parsers share the same @code{yyerror} calling +Finally, GLR and Yacc parsers share the same @code{yyerror} calling convention for absolutely pure parsers, i.e., when the calling convention of @code{yylex} @emph{and} the calling convention of @code{%define api.pure} are pure. @@ -6159,7 +6159,7 @@ Return immediately from @code{yyparse}, indicating success. @findex YYBACKUP Unshift a token. This macro is allowed only for rules that reduce a single value, and only when there is no lookahead token. -It is also disallowed in @acronym{GLR} parsers. +It is also disallowed in GLR parsers. It installs a lookahead token with token type @var{token} and semantic value @var{value}; then it discards the value that was going to be reduced by this rule. @@ -6285,19 +6285,19 @@ also supports outputting diagnostics in the user's native language. To make this work, the user should set the usual environment variables. @xref{Users, , The User's View, gettext, GNU @code{gettext} utilities}. For example, the shell command @samp{export LC_ALL=fr_CA.UTF-8} might -set the user's locale to French Canadian using the @acronym{UTF}-8 +set the user's locale to French Canadian using the UTF-8 encoding. The exact set of available locales depends on the user's installation. The maintainer of a package that uses a Bison-generated parser enables the internationalization of the parser's output through the following -steps. Here we assume a package that uses @acronym{GNU} Autoconf and -@acronym{GNU} Automake. +steps. Here we assume a package that uses GNU Autoconf and +GNU Automake. @enumerate @item @cindex bison-i18n.m4 -Into the directory containing the @acronym{GNU} Autoconf macros used +Into the directory containing the GNU Autoconf macros used by the package---often called @file{m4}---copy the @file{bison-i18n.m4} file installed by Bison under @samp{share/aclocal/bison-i18n.m4} in Bison's installation directory. @@ -6975,12 +6975,12 @@ name_list: It would seem that this grammar can be parsed with only a single token of lookahead: when a @code{param_spec} is being read, an @code{ID} is a @code{name} if a comma or colon follows, or a @code{type} if another -@code{ID} follows. In other words, this grammar is @acronym{LR}(1). +@code{ID} follows. In other words, this grammar is LR(1). -@cindex @acronym{LR}(1) -@cindex @acronym{LALR}(1) +@cindex LR(1) +@cindex LALR(1) However, for historical reasons, Bison cannot by default handle all -@acronym{LR}(1) grammars. +LR(1) grammars. In this grammar, two contexts, that after an @code{ID} at the beginning of a @code{param_spec} and likewise at the beginning of a @code{return_spec}, are similar enough that Bison assumes they are the @@ -6991,21 +6991,21 @@ a @code{type}. Bison is unable to determine at that stage of processing that the rules would require different lookahead tokens in the two contexts, so it makes a single parser state for them both. Combining the two contexts causes a conflict later. In parser terminology, this -occurrence means that the grammar is not @acronym{LALR}(1). +occurrence means that the grammar is not LALR(1). For many practical grammars (specifically those that fall into the -non-@acronym{LR}(1) class), the limitations of @acronym{LALR}(1) result in +non-LR(1) class), the limitations of LALR(1) result in difficulties beyond just mysterious reduce/reduce conflicts. The best way to fix all these problems is to select a different parser table generation algorithm. -Either @acronym{IELR}(1) or canonical @acronym{LR}(1) would suffice, but +Either IELR(1) or canonical LR(1) would suffice, but the former is more efficient and easier to debug during development. @xref{Decl Summary,,lr.type}, for details. -(Bison's @acronym{IELR}(1) and canonical @acronym{LR}(1) implementations +(Bison's IELR(1) and canonical LR(1) implementations are experimental. More user feedback will help to stabilize them.) -If you instead wish to work around @acronym{LALR}(1)'s limitations, you +If you instead wish to work around LALR(1)'s limitations, you can often fix a mysterious conflict by identifying the two parser states that are being confused, and adding something to make them look distinct. In the above example, adding one rule to @@ -7051,17 +7051,17 @@ return_spec: ; @end example -For a more detailed exposition of @acronym{LALR}(1) parsers and parser +For a more detailed exposition of LALR(1) parsers and parser generators, please see: Frank DeRemer and Thomas Pennello, Efficient Computation of -@acronym{LALR}(1) Look-Ahead Sets, @cite{@acronym{ACM} Transactions on +LALR(1) Look-Ahead Sets, @cite{ACM Transactions on Programming Languages and Systems}, Vol.@: 4, No.@: 4 (October 1982), pp.@: 615--649 @uref{http://doi.acm.org/10.1145/69622.357187}. @node Generalized LR Parsing -@section Generalized @acronym{LR} (@acronym{GLR}) Parsing -@cindex @acronym{GLR} parsing -@cindex generalized @acronym{LR} (@acronym{GLR}) parsing +@section Generalized LR (GLR) Parsing +@cindex GLR parsing +@cindex generalized LR (GLR) parsing @cindex ambiguous grammars @cindex nondeterministic parsing @@ -7081,18 +7081,18 @@ summarize the input seen so far loses necessary information. When you use the @samp{%glr-parser} declaration in your grammar file, Bison generates a parser that uses a different algorithm, called -Generalized @acronym{LR} (or @acronym{GLR}). A Bison @acronym{GLR} +Generalized LR (or GLR). A Bison GLR parser uses the same basic algorithm for parsing as an ordinary Bison parser, but behaves differently in cases where there is a shift-reduce conflict that has not been resolved by precedence rules (@pxref{Precedence}) or a -reduce-reduce conflict. When a @acronym{GLR} parser encounters such a +reduce-reduce conflict. When a GLR parser encounters such a situation, it effectively @emph{splits} into a several parsers, one for each possible shift or reduction. These parsers then proceed as usual, consuming tokens in lock-step. Some of the stacks may encounter other conflicts and split further, with the result that instead of a sequence of states, -a Bison @acronym{GLR} parsing stack is what is in effect a tree of states. +a Bison GLR parsing stack is what is in effect a tree of states. In effect, each stack represents a guess as to what the proper parse is. Additional input may indicate that a guess was wrong, in which case @@ -7120,10 +7120,10 @@ rules by the @samp{%merge} declaration, Bison resolves and evaluates both and then calls the merge function on the result. Otherwise, it reports an ambiguity. -It is possible to use a data structure for the @acronym{GLR} parsing tree that -permits the processing of any @acronym{LR}(1) grammar in linear time (in the +It is possible to use a data structure for the GLR parsing tree that +permits the processing of any LR(1) grammar in linear time (in the size of the input), any unambiguous (not necessarily -@acronym{LR}(1)) grammar in +LR(1)) grammar in quadratic worst-case time, and any general (possibly ambiguous) context-free grammar in cubic worst-case time. However, Bison currently uses a simpler data structure that requires time proportional to the @@ -7133,13 +7133,13 @@ grammars can require exponential time and space to process. Such badly behaving examples, however, are not generally of practical interest. Usually, nondeterminism in a grammar is local---the parser is ``in doubt'' only for a few tokens at a time. Therefore, the current data -structure should generally be adequate. On @acronym{LR}(1) portions of a +structure should generally be adequate. On LR(1) portions of a grammar, in particular, it is only slightly slower than with the -deterministic @acronym{LR}(1) Bison parser. +deterministic LR(1) Bison parser. -For a more detailed exposition of @acronym{GLR} parsers, please see: Elizabeth +For a more detailed exposition of GLR parsers, please see: Elizabeth Scott, Adrian Johnstone and Shamsa Sadaf Hussain, Tomita-Style -Generalised @acronym{LR} Parsers, Royal Holloway, University of +Generalised LR Parsers, Royal Holloway, University of London, Department of Computer Science, TR-00-12, @uref{http://www.cs.rhul.ac.uk/research/languages/publications/tomita_style_1.ps}, (2000-12-24). @@ -7352,7 +7352,7 @@ This looks like a function call statement, but if @code{foo} is a typedef name, then this is actually a declaration of @code{x}. How can a Bison parser for C decide how to parse this input? -The method used in @acronym{GNU} C is to have two different token types, +The method used in GNU C is to have two different token types, @code{IDENTIFIER} and @code{TYPENAME}. When @code{yylex} finds an identifier, it looks up the current declaration of the identifier in order to decide which token type to return: @code{TYPENAME} if the identifier is @@ -7957,21 +7957,21 @@ There are several means to enable compilation of trace facilities: @item the macro @code{YYDEBUG} @findex YYDEBUG Define the macro @code{YYDEBUG} to a nonzero value when you compile the -parser. This is compliant with @acronym{POSIX} Yacc. You could use +parser. This is compliant with POSIX Yacc. You could use @samp{-DYYDEBUG=1} as a compiler option or you could put @samp{#define YYDEBUG 1} in the prologue of the grammar file (@pxref{Prologue, , The Prologue}). @item the option @option{-t}, @option{--debug} Use the @samp{-t} option when you run Bison (@pxref{Invocation, -,Invoking Bison}). This is @acronym{POSIX} compliant too. +,Invoking Bison}). This is POSIX compliant too. @item the directive @samp{%debug} @findex %debug Add the @code{%debug} directive (@pxref{Decl Summary, ,Bison Declaration Summary}). This is a Bison extension, which will prove useful when Bison will output parsers for languages that don't use a -preprocessor. Unless @acronym{POSIX} and Yacc portability matter to +preprocessor. Unless POSIX and Yacc portability matter to you, this is the preferred solution. @end table @@ -8094,7 +8094,7 @@ bison -d -o @var{output.c++} @var{infile.y} @noindent will produce @file{output.c++} and @file{outfile.h++}. -For compatibility with @acronym{POSIX}, the standard Bison +For compatibility with POSIX, the standard Bison distribution also contains a shell script called @command{yacc} that invokes Bison with the @option{-y} option. @@ -8149,7 +8149,7 @@ Also, if generating a deterministic parser in C, generate @code{#define} statements in addition to an @code{enum} to associate token numbers with token names. Thus, the following shell script can substitute for Yacc, and the Bison -distribution contains such a script for compatibility with @acronym{POSIX}: +distribution contains such a script for compatibility with POSIX: @example #! /bin/sh @@ -8188,7 +8188,7 @@ be false alarms in existing grammars employing the Yacc constructs @item yacc -Incompatibilities with @acronym{POSIX} Yacc. +Incompatibilities with POSIX Yacc. @item all All the warnings. @@ -8200,7 +8200,7 @@ Treat warnings as errors. A category can be turned off by prefixing its name with @samp{no-}. For instance, @option{-Wno-yacc} will hide the warnings about -@acronym{POSIX} Yacc incompatibilities. +POSIX Yacc incompatibilities. @end table @noindent @@ -8347,7 +8347,7 @@ described under the @samp{-v} and @samp{-d} options. @itemx --graph[=@var{file}] Output a graphical representation of the parser's automaton computed by Bison, in @uref{http://www.graphviz.org/, Graphviz} -@uref{http://www.graphviz.org/doc/info/lang.html, @acronym{DOT}} format. +@uref{http://www.graphviz.org/doc/info/lang.html, DOT} format. @code{@var{file}} is optional. If omitted and the grammar file is @file{foo.y}, the output file will be @file{foo.dot}. @@ -8378,10 +8378,10 @@ the corresponding short option and directive. The Yacc library contains default implementations of the @code{yyerror} and @code{main} functions. These default -implementations are normally not useful, but @acronym{POSIX} requires +implementations are normally not useful, but POSIX requires them. To use the Yacc library, link your program with the @option{-ly} option. Note that Bison's implementation of the Yacc -library is distributed under the terms of the @acronym{GNU} General +library is distributed under the terms of the GNU General Public License (@pxref{Copying}). If you use the Yacc library's @code{yyerror} function, you should @@ -9185,7 +9185,7 @@ Java. Push parsers are currently unsupported in Java and @code{%define api.push-pull} have no effect. -@acronym{GLR} parsers are currently unsupported in Java. Do not use the +GLR parsers are currently unsupported in Java. Do not use the @code{glr-parser} directive. No header file can be generated for Java parsers. Do not use the @@ -9723,7 +9723,7 @@ are addressed. * Strings are Destroyed:: @code{yylval} Loses Track of Strings * Implementing Gotos/Loops:: Control Flow in the Calculator * Multiple start-symbols:: Factoring closely related grammars -* Secure? Conform?:: Is Bison @acronym{POSIX} safe? +* Secure? Conform?:: Is Bison POSIX safe? * I can't build Bison:: Troubleshooting * Where can I find help?:: Troubleshouting * Bug Reports:: Troublereporting @@ -9910,11 +9910,11 @@ i.e., precisely those that have a straightforward execution model: execute simple instructions one after the others. @cindex abstract syntax tree -@cindex @acronym{AST} +@cindex 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, +or @dfn{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. @@ -9981,7 +9981,7 @@ Is Bison secure? Does it conform to POSIX? If you're looking for a guarantee or certification, we don't provide it. However, Bison is intended to be a reliable program that conforms to the -@acronym{POSIX} specification for Yacc. If you run into problems, +POSIX specification for Yacc. If you run into problems, please send us a bug report. @node I can't build Bison @@ -10240,7 +10240,7 @@ discarded symbols. @xref{Destructor Decl, , Freeing Discarded Symbols}. @deffn {Directive} %dprec Bison declaration to assign a precedence to a rule that is used at parse time to resolve reduce/reduce conflicts. @xref{GLR Parsers, ,Writing -@acronym{GLR} Parsers}. +GLR Parsers}. @end deffn @deffn {Symbol} $end @@ -10270,8 +10270,8 @@ Summary}. @end deffn @deffn {Directive} %glr-parser -Bison declaration to produce a @acronym{GLR} parser. @xref{GLR -Parsers, ,Writing @acronym{GLR} Parsers}. +Bison declaration to produce a GLR parser. @xref{GLR +Parsers, ,Writing GLR Parsers}. @end deffn @deffn {Directive} %initial-action @@ -10298,7 +10298,7 @@ for Pure Parsers}. Bison declaration to assign a merging function to a rule. If there is a reduce/reduce conflict with a rule having the same merging function, the function is applied to the two semantic values to get a single result. -@xref{GLR Parsers, ,Writing @acronym{GLR} Parsers}. +@xref{GLR Parsers, ,Writing GLR Parsers}. @end deffn @deffn {Directive} %name-prefix "@var{prefix}" @@ -10608,7 +10608,7 @@ A state whose only action is the accept action. The accepting state is thus a consistent state. @xref{Understanding,,}. -@item Backus-Naur Form (@acronym{BNF}; also called ``Backus Normal Form'') +@item Backus-Naur Form (BNF; also called ``Backus Normal Form'') Formal method of specifying context-free grammars originally proposed by John Backus, and slightly improved by Peter Naur in his 1960-01-02 committee document contributing to what became the Algol 60 report. @@ -10649,31 +10649,31 @@ machine. In the case of the parser, the input is the language being parsed, and the states correspond to various stages in the grammar rules. @xref{Algorithm, ,The Bison Parser Algorithm}. -@item Generalized @acronym{LR} (@acronym{GLR}) +@item Generalized LR (GLR) A parsing algorithm that can handle all context-free grammars, including those -that are not @acronym{LR}(1). It resolves situations that Bison's +that are not LR(1). It resolves situations that Bison's deterministic parsing algorithm cannot by effectively splitting off multiple parsers, trying all possible parsers, and discarding those that fail in the light of additional right context. @xref{Generalized LR Parsing, ,Generalized -@acronym{LR} Parsing}. +LR Parsing}. @item Grouping A language construct that is (in general) grammatically divisible; for example, `expression' or `declaration' in C@. @xref{Language and Grammar, ,Languages and Context-Free Grammars}. -@item @acronym{IELR}(1) -A minimal @acronym{LR}(1) parser table generation algorithm. -That is, given any context-free grammar, @acronym{IELR}(1) generates +@item IELR(1) +A minimal LR(1) parser table generation algorithm. +That is, given any context-free grammar, IELR(1) generates parser tables with the full language recognition power of canonical -@acronym{LR}(1) but with nearly the same number of parser states as -@acronym{LALR}(1). +LR(1) but with nearly the same number of parser states as +LALR(1). This reduction in parser states is often an order of magnitude. -More importantly, because canonical @acronym{LR}(1)'s extra parser +More importantly, because canonical LR(1)'s extra parser states may contain duplicate conflicts in the case of -non-@acronym{LR}(1) grammars, the number of conflicts for -@acronym{IELR}(1) is often an order of magnitude less as well. +non-LR(1) grammars, the number of conflicts for +IELR(1) is often an order of magnitude less as well. This can significantly reduce the complexity of developing of a grammar. @xref{Decl Summary,,lr.type}. @@ -10684,7 +10684,7 @@ performs some operation. @item Input stream A continuous flow of data between devices or programs. -@item @acronym{LAC} (Lookahead Correction) +@item LAC (Lookahead Correction) A parsing mechanism that fixes the problem of delayed syntax error detection, which is caused by LR state merging, default reductions, and the use of @code{%nonassoc}. Delayed syntax error detection results in @@ -10726,12 +10726,12 @@ A token which consists of two or more fixed characters. @xref{Symbols}. A token already read but not yet shifted. @xref{Lookahead, ,Lookahead Tokens}. -@item @acronym{LALR}(1) +@item LALR(1) The class of context-free grammars that Bison (like most other parser -generators) can handle by default; a subset of @acronym{LR}(1). +generators) can handle by default; a subset of LR(1). @xref{Mystery Conflicts, ,Mysterious Reduce/Reduce Conflicts}. -@item @acronym{LR}(1) +@item LR(1) The class of context-free grammars in which at most one token of lookahead is needed to disambiguate the parsing of any piece of input. -- 2.45.2