* doc/bison.texinfo: minor typo fixes

[bison.git] / doc / bison.texinfo

diff --git a/doc/bison.texinfo b/doc/bison.texinfo
index 9d7dcd864f42432724eadf69bb0c4c906776846f..6d7a81ec059249f268317865deaa9873a5931559 100644 (file)
--- a/doc/bison.texinfo
+++ b/doc/bison.texinfo
@@ -44,12 +44,12 @@ This manual is for @acronym{GNU} Bison (version @value{VERSION},
 @value{UPDATED}), the @acronym{GNU} parser generator.
 
 Copyright @copyright{} 1988, 1989, 1990, 1991, 1992, 1993, 1995, 1998,
 @value{UPDATED}), the @acronym{GNU} parser generator.
 
 Copyright @copyright{} 1988, 1989, 1990, 1991, 1992, 1993, 1995, 1998,

-1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+1999, 2000, 2001, 2002, 2003, 2004, 2005 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,
 
 @quotation
 Permission is granted to copy, distribute and/or modify this document
 under the terms of the @acronym{GNU} Free Documentation License,

-Version 1.1 or any later version published by the Free Software
+Version 1.2 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
 (a) below.  A copy of the license is included in the section entitled
 Foundation; with no Invariant Sections, with the Front-Cover texts
 being ``A @acronym{GNU} Manual,'' and with the Back-Cover Texts as in
 (a) below.  A copy of the license is included in the section entitled


@@ -62,7 +62,7 @@ Copies published by the Free Software Foundation raise funds for
 @end quotation
 @end copying
 
 @end quotation
 @end copying
 

-@dircategory GNU programming tools
+@dircategory Software development

 @direntry
 * bison: (bison).       @acronym{GNU} parser generator (Yacc replacement).
 @end direntry
 @direntry
 * bison: (bison).       @acronym{GNU} parser generator (Yacc replacement).
 @end direntry


@@ -444,7 +444,7 @@ 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{look-ahead}) of the remaining input.  A context-free
 grammar can be @dfn{ambiguous}, meaning that there are multiple ways to
 uniquely determined by the preceding input and a fixed, finite portion
 (called a @dfn{look-ahead}) of the remaining input.  A context-free
 grammar can be @dfn{ambiguous}, meaning that there are multiple ways to

-apply the grammar rules to get the some inputs.  Even unambiguous
+apply the grammar rules to get the same inputs.  Even unambiguous

 grammars can be @dfn{non-deterministic}, meaning that no fixed
 look-ahead always suffices to determine the next grammar rule to apply.
 With the proper declarations, Bison is also able to parse these more
 grammars can be @dfn{non-deterministic}, meaning that no fixed
 look-ahead always suffices to determine the next grammar rule to apply.
 With the proper declarations, Bison is also able to parse these more


@@ -480,7 +480,7 @@ Here is a simple C function subdivided into tokens:
 @ifinfo
 @example
 int             /* @r{keyword `int'} */
 @ifinfo
 @example
 int             /* @r{keyword `int'} */

-square (int x)  /* @r{identifier, open-paren, identifier,}
+square (int x)  /* @r{identifier, open-paren, keyword `int',}

                    @r{identifier, close-paren} */
 @{               /* @r{open-brace} */
   return x * x; /* @r{keyword `return', identifier, asterisk,
                    @r{identifier, close-paren} */
 @{               /* @r{open-brace} */
   return x * x; /* @r{keyword `return', identifier, asterisk,


@@ -491,7 +491,7 @@ square (int x)  /* @r{identifier, open-paren, identifier,}
 @ifnotinfo
 @example
 int             /* @r{keyword `int'} */
 @ifnotinfo
 @example
 int             /* @r{keyword `int'} */

-square (int x)  /* @r{identifier, open-paren, identifier, identifier, close-paren} */
+square (int x)  /* @r{identifier, open-paren, keyword `int', identifier, close-paren} */

 @{               /* @r{open-brace} */
   return x * x; /* @r{keyword `return', identifier, asterisk, identifier, semicolon} */
 @}               /* @r{close-brace} */
 @{               /* @r{open-brace} */
   return x * x; /* @r{keyword `return', identifier, asterisk, identifier, semicolon} */
 @}               /* @r{close-brace} */


@@ -2627,7 +2627,7 @@ not come before the definition of @code{yyparse}.  For example, the
 definitions of @code{yylex} and @code{yyerror} often go here.  Because
 C requires functions to be declared before being used, you often need
 to declare functions like @code{yylex} and @code{yyerror} in the Prologue,
 definitions of @code{yylex} and @code{yyerror} often go here.  Because
 C requires functions to be declared before being used, you often need
 to declare functions like @code{yylex} and @code{yyerror} in the Prologue,

-even if you define them int he Epilogue.
+even if you define them in the Epilogue.

 @xref{Interface, ,Parser C-Language Interface}.
 
 If the last section is empty, you may omit the @samp{%%} that separates it
 @xref{Interface, ,Parser C-Language Interface}.
 
 If the last section is empty, you may omit the @samp{%%} that separates it


@@ -3446,38 +3446,40 @@ dedicated code from semantic actions.
 
 The @code{YYLLOC_DEFAULT} macro takes three parameters.  The first one is
 the location of the grouping (the result of the computation).  When a
 
 The @code{YYLLOC_DEFAULT} macro takes three parameters.  The first one is
 the location of the grouping (the result of the computation).  When a

-rule is matched, the second parameter is an array holding locations of
+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 processing
 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 processing

-a syntax error, the second parameter is an array holding locations of
+a syntax error, the second parameter identifies locations of

 the symbols that were discarded during error processing, and the third
 parameter is the number of discarded symbols.
 
 the symbols that were discarded during error processing, and the third
 parameter is the number of discarded symbols.
 

-By default, @code{YYLLOC_DEFAULT} is defined this way for simple
-@acronym{LALR}(1) parsers:
+By default, @code{YYLLOC_DEFAULT} is defined this way:

 
 

-@example
+@smallexample

 @group
 @group

-# define YYLLOC_DEFAULT(Current, Rhs, N)               \
-   ((Current).first_line   = (Rhs)[1].first_line,      \
-    (Current).first_column = (Rhs)[1].first_column,    \
-    (Current).last_line    = (Rhs)[N].last_line,       \
-    (Current).last_column  = (Rhs)[N].last_column)
+# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+    do                                                                  \
+      if (N)                                                            \
+        @{                                                               \
+          (Current).first_line   = YYRHSLOC(Rhs, 1).first_line;         \
+          (Current).first_column = YYRHSLOC(Rhs, 1).first_column;       \
+          (Current).last_line    = YYRHSLOC(Rhs, N).last_line;          \
+          (Current).last_column  = YYRHSLOC(Rhs, N).last_column;        \
+        @}                                                               \
+      else                                                              \
+        @{                                                               \
+          (Current).first_line   = (Current).last_line   =              \
+            YYRHSLOC(Rhs, 0).last_line;                                 \
+          (Current).first_column = (Current).last_column =              \
+            YYRHSLOC(Rhs, 0).last_column;                               \
+        @}                                                               \
+    while (0)

 @end group
 @end group

-@end example
-
-@noindent
-and like this for @acronym{GLR} parsers:
+@end smallexample

 
 

-@example
-@group
-# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN)                 \
-   ((yyCurrent).first_line = YYRHSLOC(yyRhs, 1).first_line,    \
-    (yyCurrent).first_column = YYRHSLOC(yyRhs, 1).first_column,        \
-    (yyCurrent).last_line = YYRHSLOC(yyRhs, YYN).last_line,    \
-    (yyCurrent).last_column  = YYRHSLOC(yyRhs, YYN).last_column)
-@end group
-@end example
+where @code{YYRHSLOC (rhs, k)} is the location of the @var{k}th symbol
+in @var{rhs} when @var{k} is positive, and the location of the symbol
+just before the reduction when @var{k} and @var{n} are both zero.

 
 When defining @code{YYLLOC_DEFAULT}, you should consider that:
 
 
 When defining @code{YYLLOC_DEFAULT}, you should consider that:
 


@@ -3487,8 +3489,10 @@ All arguments are free of side-effects.  However, only the first one (the
 result) should be modified by @code{YYLLOC_DEFAULT}.
 
 @item
 result) should be modified by @code{YYLLOC_DEFAULT}.
 
 @item

-For consistency with semantic actions, valid indexes for the location
-array range from 1 to @var{n}.
+For consistency with semantic actions, valid indexes within the
+right hand side range from 1 to @var{n}.  When @var{n} is zero, only 0 is a
+valid index, and it refers to the symbol just before the reduction.
+During error processing @var{n} is always positive.

 
 @item
 Your macro should parenthesize its arguments, if need be, since the
 
 @item
 Your macro should parenthesize its arguments, if need be, since the


@@ -5570,7 +5574,6 @@ By defining the macro @code{YYMAXDEPTH}, you can control how deep the
 parser stack can become before a stack overflow occurs.  Define the
 macro with a value that is an integer.  This value is the maximum number
 of tokens that can be shifted (and not reduced) before overflow.
 parser stack can become before a stack overflow occurs.  Define the
 macro with a value that is an integer.  This value is the maximum number
 of tokens that can be shifted (and not reduced) before overflow.

-It must be a constant expression whose value is known at compile time.

 
 The stack space allowed is not necessarily allocated.  If you specify a
 large value for @code{YYMAXDEPTH}, the parser actually allocates a small
 
 The stack space allowed is not necessarily allocated.  If you specify a
 large value for @code{YYMAXDEPTH}, the parser actually allocates a small


@@ -5579,14 +5582,26 @@ increasing allocation happens automatically and silently.  Therefore,
 you do not need to make @code{YYMAXDEPTH} painfully small merely to save
 space for ordinary inputs that do not need much stack.
 
 you do not need to make @code{YYMAXDEPTH} painfully small merely to save
 space for ordinary inputs that do not need much stack.
 

+However, do not allow @code{YYMAXDEPTH} to be a value so large that
+arithmetic overflow could occur when calculating the size of the stack
+space.  Also, do not allow @code{YYMAXDEPTH} to be less than
+@code{YYINITDEPTH}.
+

 @cindex default stack limit
 The default value of @code{YYMAXDEPTH}, if you do not define it, is
 10000.
 
 @vindex YYINITDEPTH
 You can control how much stack is allocated initially by defining the
 @cindex default stack limit
 The default value of @code{YYMAXDEPTH}, if you do not define it, is
 10000.
 
 @vindex YYINITDEPTH
 You can control how much stack is allocated initially by defining the

-macro @code{YYINITDEPTH}.  This value too must be a compile-time
-constant integer.  The default is 200.
+macro @code{YYINITDEPTH} to a positive integer.  For the C
+@acronym{LALR}(1) parser, this value must be a compile-time constant
+unless you are assuming C99 or some other target language or compiler
+that allows variable-length arrays.  The default is 200.
+
+Do not allow @code{YYINITDEPTH} to be a value so large that arithmetic
+overflow would occur when calculating the size of the stack space.
+Also, do not allow @code{YYINITDEPTH} to be greater than
+@code{YYMAXDEPTH}.

 
 @c FIXME: C++ output.
 Because of semantical differences between C and C++, the
 
 @c FIXME: C++ output.
 Because of semantical differences between C and C++, the


@@ -7302,10 +7317,23 @@ syntax error.  @xref{Action Features, ,Special Features for Use in Actions}.
 @end deffn
 
 @deffn {Macro} YYSTACK_USE_ALLOCA
 @end deffn
 
 @deffn {Macro} YYSTACK_USE_ALLOCA

-Macro used to control the use of @code{alloca}.  If defined to @samp{0},
-the parser will not use @code{alloca} but @code{malloc} when trying to
-grow its internal stacks.  Do @emph{not} define @code{YYSTACK_USE_ALLOCA}
-to anything else.
+Macro used to control the use of @code{alloca} when the C
+@acronym{LALR}(1) parser needs to extend its stacks.  If defined to 0,
+the parser will use @code{malloc} to extend its stacks.  If defined to
+1, the parser will use @code{alloca}.  Values other than 0 and 1 are
+reserved for future Bison extensions.  If not defined,
+@code{YYSTACK_USE_ALLOCA} defaults to 0.
+
+If you define @code{YYSTACK_USE_ALLOCA} to 1, it is your
+responsibility to make sure that @code{alloca} is visible, e.g., by
+using @acronym{GCC} or by including @code{<stdlib.h>}.  Furthermore,
+in the all-too-common case where your code may run on a host with a
+limited stack and with unreliable stack-overflow checking, you should
+set @code{YYMAXDEPTH} to a value that cannot possibly result in
+unchecked stack overflow on any of your target hosts when
+@code{alloca} is called.  You can inspect the code that Bison
+generates in order to determine the proper numeric values.  This will
+require some expertise in low-level implementation details.

 @end deffn
 
 @deffn {Type} YYSTYPE
 @end deffn
 
 @deffn {Type} YYSTYPE