* NEWS (2.3b+): New section, empty for now.

[bison.git] / doc / bison.texinfo

diff --git a/doc/bison.texinfo b/doc/bison.texinfo
index 4b49c8113370810f784ad85fe73423cd774b9aed..b6a98f9db3c2fb7a0ed58a97950c7a3200a43d6e 100644 (file)
--- a/doc/bison.texinfo
+++ b/doc/bison.texinfo
@@ -34,7 +34,8 @@ 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, 2005, 2006, 2007 Free Software Foundation, Inc.
+1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software
+Foundation, Inc.

 
 @quotation
 Permission is granted to copy, distribute and/or modify this document
 
 @quotation
 Permission is granted to copy, distribute and/or modify this document


@@ -45,10 +46,10 @@ 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
 ``@acronym{GNU} Free Documentation License.''
 
 (a) below.  A copy of the license is included in the section entitled
 ``@acronym{GNU} Free Documentation License.''
 

-(a) The @acronym{FSF}'s Back-Cover Text is: ``You have freedom to copy
-and modify this @acronym{GNU} Manual, like @acronym{GNU} software.
-Copies published by the Free Software Foundation raise funds for
-@acronym{GNU} development.''
+(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
+freedom.''

 @end quotation
 @end copying
 
 @end quotation
 @end copying
 


@@ -4022,7 +4023,7 @@ associativity and precedence.  @xref{Precedence Decl, ,Operator
 Precedence}.
 
 You can explicitly specify the numeric code for a token type by appending
 Precedence}.
 
 You can explicitly specify the numeric code for a token type by appending

-a decimal or hexadecimal integer value in the field immediately
+a nonnegative decimal or hexadecimal integer value in the field immediately

 following the token name:
 
 @example
 following the token name:
 
 @example


@@ -4075,6 +4076,16 @@ Once you equate the literal string and the token name, you can use them
 interchangeably in further declarations or the grammar rules.  The
 @code{yylex} function can use the token name or the literal string to
 obtain the token type code number (@pxref{Calling Convention}).
 interchangeably in further declarations or the grammar rules.  The
 @code{yylex} function can use the token name or the literal string to
 obtain the token type code number (@pxref{Calling Convention}).

+Syntax error messages passed to @code{yyerror} from the parser will reference
+the literal string instead of the token name.
+
+The token numbered as 0 corresponds to end of file; the following line
+allows for nicer error messages referring to ``end of file'' instead
+of ``$end'':
+
+@example
+%token END 0 "end of file"
+@end example

 
 @node Precedence Decl
 @subsection Operator Precedence
 
 @node Precedence Decl
 @subsection Operator Precedence


@@ -4088,7 +4099,7 @@ once.  These are called @dfn{precedence declarations}.
 @xref{Precedence, ,Operator Precedence}, for general information on
 operator precedence.
 
 @xref{Precedence, ,Operator Precedence}, for general information on
 operator precedence.
 

-The syntax of a precedence declaration is the same as that of
+The syntax of a precedence declaration is nearly the same as that of

 @code{%token}: either
 
 @example
 @code{%token}: either
 
 @example


@@ -4126,6 +4137,18 @@ When two tokens declared in different precedence declarations associate,
 the one declared later has the higher precedence and is grouped first.
 @end itemize
 
 the one declared later has the higher precedence and is grouped first.
 @end itemize
 

+For backward compatibility, there is a confusing difference between the
+argument lists of @code{%token} and precedence declarations.
+Only a @code{%token} can associate a literal string with a token type name.
+A precedence declaration always interprets a literal string as a reference to a
+separate token.
+For example:
+
+@example
+%left  OR "<="         // Does not declare an alias.
+%left  OR 134 "<=" 135 // Declares 134 for OR and 135 for "<=".
+@end example
+

 @node Union Decl
 @subsection The Collection of Value Types
 @cindex declaring value types
 @node Union Decl
 @subsection The Collection of Value Types
 @cindex declaring value types


@@ -4487,7 +4510,7 @@ may override this restriction with the @code{%start} declaration as follows:
 @subsection A Pure (Reentrant) Parser
 @cindex reentrant parser
 @cindex pure parser
 @subsection A Pure (Reentrant) Parser
 @cindex reentrant parser
 @cindex pure parser

-@findex %pure-parser
+@findex %define api.pure

 
 A @dfn{reentrant} program is one which does not alter in the course of
 execution; in other words, it consists entirely of @dfn{pure} (read-only)
 
 A @dfn{reentrant} program is one which does not alter in the course of
 execution; in other words, it consists entirely of @dfn{pure} (read-only)


@@ -4503,19 +4526,19 @@ statically allocated variables for communication with @code{yylex},
 including @code{yylval} and @code{yylloc}.)
 
 Alternatively, you can generate a pure, reentrant parser.  The Bison
 including @code{yylval} and @code{yylloc}.)
 
 Alternatively, you can generate a pure, reentrant parser.  The Bison

-declaration @code{%pure-parser} says that you want the parser to be
+declaration @code{%define api.pure} says that you want the parser to be

 reentrant.  It looks like this:
 
 @example
 reentrant.  It looks like this:
 
 @example

-%pure-parser
+%define api.pure

 @end example
 
 The result is that the communication variables @code{yylval} and
 @code{yylloc} become local variables in @code{yyparse}, and a different
 calling convention is used for the lexical analyzer function
 @code{yylex}.  @xref{Pure Calling, ,Calling Conventions for Pure
 @end example
 
 The result is that the communication variables @code{yylval} and
 @code{yylloc} become local variables in @code{yyparse}, and a different
 calling convention is used for the lexical analyzer function
 @code{yylex}.  @xref{Pure Calling, ,Calling Conventions for Pure

-Parsers}, for the details of this.  The variable @code{yynerrs} 
-becomes local in @code{yyparse} in pull mode but it becomes a member 
+Parsers}, for the details of this.  The variable @code{yynerrs}
+becomes local in @code{yyparse} in pull mode but it becomes a member

 of yypstate in push mode.  (@pxref{Error Reporting, ,The Error
 Reporting Function @code{yyerror}}).  The convention for calling
 @code{yyparse} itself is unchanged.
 of yypstate in push mode.  (@pxref{Error Reporting, ,The Error
 Reporting Function @code{yyerror}}).  The convention for calling
 @code{yyparse} itself is unchanged.


@@ -4528,47 +4551,50 @@ valid grammar.
 @subsection A Push Parser
 @cindex push parser
 @cindex push parser
 @subsection A Push Parser
 @cindex push parser
 @cindex push parser

-@findex %define push_pull
+@findex %define api.push_pull
+
+(The current push parsing interface is experimental and may evolve.
+More user feedback will help to stabilize it.)

 
 

-A pull parser is called once and it takes control until all its input 
-is completely parsed.  A push parser, on the other hand, is called 
+A pull parser is called once and it takes control until all its input
+is completely parsed.  A push parser, on the other hand, is called

 each time a new token is made available.
 
 each time a new token is made available.
 

-A push parser is typically useful when the parser is part of a 
+A push parser is typically useful when the parser is part of a

 main event loop in the client's application.  This is typically
 main event loop in the client's application.  This is typically

-a requirement of a GUI, when the main event loop needs to be triggered 
-within a certain time period.  
+a requirement of a GUI, when the main event loop needs to be triggered
+within a certain time period.

 
 Normally, Bison generates a pull parser.
 The following Bison declaration says that you want the parser to be a push
 
 Normally, Bison generates a pull parser.
 The following Bison declaration says that you want the parser to be a push

-parser (@pxref{Decl Summary,,%define push_pull}):
+parser (@pxref{Decl Summary,,%define api.push_pull}):

 
 @example
 
 @example

-%define push_pull "push"
+%define api.push_pull "push"

 @end example
 
 In almost all cases, you want to ensure that your push parser is also
 a pure parser (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).  The only
 @end example
 
 In almost all cases, you want to ensure that your push parser is also
 a pure parser (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).  The only

-time you should create an impure push parser is to have backwards 
+time you should create an impure push parser is to have backwards

 compatibility with the impure Yacc pull mode interface.  Unless you know
 what you are doing, your declarations should look like this:
 
 @example
 compatibility with the impure Yacc pull mode interface.  Unless you know
 what you are doing, your declarations should look like this:
 
 @example

-%pure-parser
-%define push_pull "push"
+%define api.pure
+%define api.push_pull "push"

 @end example
 
 @end example
 

-There is a major notable functional difference between the pure push parser 
-and the impure push parser.  It is acceptable for a pure push parser to have 
+There is a major notable functional difference between the pure push parser
+and the impure push parser.  It is acceptable for a pure push parser to have

 many parser instances, of the same type of parser, in memory at the same time.
 An impure push parser should only use one parser at a time.
 
 When a push parser is selected, Bison will generate some new symbols in
 many parser instances, of the same type of parser, in memory at the same time.
 An impure push parser should only use one parser at a time.
 
 When a push parser is selected, Bison will generate some new symbols in

-the generated parser.  @code{yypstate} is a structure that the generated 
-parser uses to store the parser's state.  @code{yypstate_new} is the 
+the generated parser.  @code{yypstate} is a structure that the generated
+parser uses to store the parser's state.  @code{yypstate_new} is the

 function that will create a new parser instance.  @code{yypstate_delete}
 will free the resources associated with the corresponding parser instance.
 function that will create a new parser instance.  @code{yypstate_delete}
 will free the resources associated with the corresponding parser instance.

-Finally, @code{yypush_parse} is the function that should be called whenever a 
+Finally, @code{yypush_parse} is the function that should be called whenever a

 token is available to provide the parser.  A trivial example
 of using a pure push parser would look like this:
 
 token is available to provide the parser.  A trivial example
 of using a pure push parser would look like this:
 


@@ -4582,10 +4608,10 @@ yypstate_delete (ps);
 @end example
 
 If the user decided to use an impure push parser, a few things about
 @end example
 
 If the user decided to use an impure push parser, a few things about

-the generated parser will change.  The @code{yychar} variable becomes 
+the generated parser will change.  The @code{yychar} variable becomes

 a global variable instead of a variable in the @code{yypush_parse} function.
 For this reason, the signature of the @code{yypush_parse} function is
 a global variable instead of a variable in the @code{yypush_parse} function.
 For this reason, the signature of the @code{yypush_parse} function is

-changed to remove the token as a parameter.  A nonreentrant push parser 
+changed to remove the token as a parameter.  A nonreentrant push parser

 example would thus look like this:
 
 @example
 example would thus look like this:
 
 @example


@@ -4599,26 +4625,26 @@ do @{
 yypstate_delete (ps);
 @end example
 
 yypstate_delete (ps);
 @end example
 

-That's it. Notice the next token is put into the global variable @code{yychar} 
+That's it. Notice the next token is put into the global variable @code{yychar}

 for use by the next invocation of the @code{yypush_parse} function.
 
 for use by the next invocation of the @code{yypush_parse} function.
 

-Bison also supports both the push parser interface along with the pull parser 
+Bison also supports both the push parser interface along with the pull parser

 interface in the same generated parser.  In order to get this functionality,
 interface in the same generated parser.  In order to get this functionality,

-you should replace the @code{%define push_pull "push"} declaration with the 
-@code{%define push_pull "both"} declaration.  Doing this will create all of the 
-symbols mentioned earlier along with the two extra symbols, @code{yyparse} 
-and @code{yypull_parse}.  @code{yyparse} can be used exactly as it normally 
-would be used.  However, the user should note that it is implemented in the 
+you should replace the @code{%define api.push_pull "push"} declaration with the
+@code{%define api.push_pull "both"} declaration.  Doing this will create all of
+the symbols mentioned earlier along with the two extra symbols, @code{yyparse}
+and @code{yypull_parse}.  @code{yyparse} can be used exactly as it normally
+would be used.  However, the user should note that it is implemented in the

 generated parser by calling @code{yypull_parse}.
 This makes the @code{yyparse} function that is generated with the
 generated parser by calling @code{yypull_parse}.
 This makes the @code{yyparse} function that is generated with the

-@code{%define push_pull "both"} declaration slower than the normal
+@code{%define api.push_pull "both"} declaration slower than the normal

 @code{yyparse} function.  If the user
 calls the @code{yypull_parse} function it will parse the rest of the input
 @code{yyparse} function.  If the user
 calls the @code{yypull_parse} function it will parse the rest of the input

-stream.  It is possible to @code{yypush_parse} tokens to select a subgrammar 
-and then @code{yypull_parse} the rest of the input stream.  If you would like 
-to switch back and forth between between parsing styles, you would have to 
-write your own @code{yypull_parse} function that knows when to quit looking 
-for input.  An example of using the @code{yypull_parse} function would look 
+stream.  It is possible to @code{yypush_parse} tokens to select a subgrammar
+and then @code{yypull_parse} the rest of the input stream.  If you would like
+to switch back and forth between between parsing styles, you would have to
+write your own @code{yypull_parse} function that knows when to quit looking
+for input.  An example of using the @code{yypull_parse} function would look

 like this:
 
 @example
 like this:
 
 @example


@@ -4627,9 +4653,9 @@ yypull_parse (ps); /* Will call the lexer */
 yypstate_delete (ps);
 @end example
 
 yypstate_delete (ps);
 @end example
 

-Adding the @code{%pure-parser} declaration does exactly the same thing to the 
-generated parser with @code{%define push_pull "both"} as it did for 
-@code{%define push_pull "push"}.
+Adding the @code{%define api.pure} declaration does exactly the same thing to
+the generated parser with @code{%define api.push_pull "both"} as it did for
+@code{%define api.push_pull "push"}.

 
 @node Decl Summary
 @subsection Bison Declaration Summary
 
 @node Decl Summary
 @subsection Bison Declaration Summary


@@ -4837,20 +4863,79 @@ target language and/or parser skeleton.
 Some of the accepted @var{variable}s are:
 
 @itemize @bullet
 Some of the accepted @var{variable}s are:
 
 @itemize @bullet

-@item push_pull
-@findex %define push_pull
+@item api.pure
+@findex %define api.pure
+
+@itemize @bullet
+@item Language(s): C
+
+@item Purpose: Request a pure (reentrant) parser program.
+@xref{Pure Decl, ,A Pure (Reentrant) Parser}.
+
+@item Accepted Values: Boolean
+
+@item Default Value: @code{"false"}
+@end itemize
+
+@item api.push_pull
+@findex %define api.push_pull

 
 @itemize @bullet
 @item Language(s): C (LALR(1) only)
 
 @item Purpose: Requests a pull parser, a push parser, or both.
 @xref{Push Decl, ,A Push Parser}.
 
 @itemize @bullet
 @item Language(s): C (LALR(1) only)
 
 @item Purpose: Requests a pull parser, a push parser, or both.
 @xref{Push Decl, ,A Push Parser}.

+(The current push parsing interface is experimental and may evolve.
+More user feedback will help to stabilize it.)

 
 @item Accepted Values: @code{"pull"}, @code{"push"}, @code{"both"}
 
 @item Default Value: @code{"pull"}
 @end itemize
 
 
 @item Accepted Values: @code{"pull"}, @code{"push"}, @code{"both"}
 
 @item Default Value: @code{"pull"}
 @end itemize
 

+@item lr.keep_unreachable_states
+@findex %define lr.keep_unreachable_states
+
+@itemize @bullet
+@item Language(s): all
+
+@item Purpose: Requests that Bison allow unreachable parser states to remain in
+the parser tables.
+Bison considers a state to be unreachable if there exists no sequence of
+transitions from the start state to that state.
+A state can become unreachable during conflict resolution if Bison disables a
+shift action leading to it from a predecessor state.
+Keeping unreachable states is sometimes useful for analysis purposes, but they
+are useless in the generated parser.
+
+@item Accepted Values: Boolean
+
+@item Default Value: @code{"false"}
+
+@item Caveats:
+
+@itemize @bullet
+
+@item Unreachable states may contain conflicts and may use rules not used in
+any other state.
+Thus, keeping unreachable states may induce warnings that are irrelevant to
+your parser's behavior, and it may eliminate warnings that are relevant.
+Of course, the change in warnings may actually be relevant to a parser table
+analysis that wants to keep unreachable states, so this behavior will likely
+remain in future Bison releases.
+
+@item While Bison is able to remove unreachable states, it is not guaranteed to
+remove other kinds of useless states.
+Specifically, when Bison disables reduce actions during conflict resolution,
+some goto actions may become useless, and thus some additional states may
+become useless.
+If Bison were to compute which goto actions were useless and then disable those
+actions, it could identify such states as unreachable and then remove those
+states.
+However, Bison does not compute which goto actions are useless.
+@end itemize
+@end itemize
+

 @item namespace
 @findex %define namespace
 
 @item namespace
 @findex %define namespace
 


@@ -4962,7 +5047,7 @@ chosen as if the input file were named @file{@var{prefix}.y}.
 
 @deffn {Directive} %language "@var{language}"
 Specify the programming language for the generated parser.  Currently
 
 @deffn {Directive} %language "@var{language}"
 Specify the programming language for the generated parser.  Currently

-supported languages include C and C++.
+supported languages include C, C++, and Java.

 @var{language} is case-insensitive.
 @end deffn
 
 @var{language} is case-insensitive.
 @end deffn
 


@@ -4980,10 +5065,10 @@ Rename the external symbols used in the parser so that they start with
 in C parsers
 is @code{yyparse}, @code{yylex}, @code{yyerror}, @code{yynerrs},
 @code{yylval}, @code{yychar}, @code{yydebug}, and
 in C parsers
 is @code{yyparse}, @code{yylex}, @code{yyerror}, @code{yynerrs},
 @code{yylval}, @code{yychar}, @code{yydebug}, and

-(if locations are used) @code{yylloc}.  If you use a push parser, 
-@code{yypush_parse}, @code{yypull_parse}, @code{yypstate}, 
-@code{yypstate_new} and @code{yypstate_delete} will 
-also be renamed.  For example, if you use @samp{%name-prefix "c_"}, the 
+(if locations are used) @code{yylloc}.  If you use a push parser,
+@code{yypush_parse}, @code{yypull_parse}, @code{yypstate},
+@code{yypstate_new} and @code{yypstate_delete} will
+also be renamed.  For example, if you use @samp{%name-prefix "c_"}, the

 names become @code{c_parse}, @code{c_lex}, and so on.
 For C++ parsers, see the @code{%define namespace} documentation in this
 section.
 names become @code{c_parse}, @code{c_lex}, and so on.
 For C++ parsers, see the @code{%define namespace} documentation in this
 section.


@@ -5012,8 +5097,8 @@ Specify @var{file} for the parser file.
 @end deffn
 
 @deffn {Directive} %pure-parser
 @end deffn
 
 @deffn {Directive} %pure-parser

-Request a pure (reentrant) parser program (@pxref{Pure Decl, ,A Pure
-(Reentrant) Parser}).
+Deprecated version of @code{%define api.pure} (@pxref{Decl Summary, ,%define}),
+for which Bison is more careful to warn about unreasonable usage.

 @end deffn
 
 @deffn {Directive} %require "@var{version}"
 @end deffn
 
 @deffn {Directive} %require "@var{version}"


@@ -5099,10 +5184,10 @@ names that do not conflict.
 
 The precise list of symbols renamed is @code{yyparse}, @code{yylex},
 @code{yyerror}, @code{yynerrs}, @code{yylval}, @code{yylloc},
 
 The precise list of symbols renamed is @code{yyparse}, @code{yylex},
 @code{yyerror}, @code{yynerrs}, @code{yylval}, @code{yylloc},

-@code{yychar} and @code{yydebug}.  If you use a push parser, 
-@code{yypush_parse}, @code{yypull_parse}, @code{yypstate}, 
+@code{yychar} and @code{yydebug}.  If you use a push parser,
+@code{yypush_parse}, @code{yypull_parse}, @code{yypstate},

 @code{yypstate_new} and @code{yypstate_delete} will also be renamed.
 @code{yypstate_new} and @code{yypstate_delete} will also be renamed.

-For example, if you use @samp{-p c}, the names become @code{cparse}, 
+For example, if you use @samp{-p c}, the names become @code{cparse},

 @code{clex}, and so on.
 
 @strong{All the other variables and macros associated with Bison are not
 @code{clex}, and so on.
 
 @strong{All the other variables and macros associated with Bison are not


@@ -5134,9 +5219,9 @@ in the grammar file, you are likely to run into trouble.
 * Parser Function::   How to call @code{yyparse} and what it returns.
 * Push Parser Function::  How to call @code{yypush_parse} and what it returns.
 * Pull Parser Function::  How to call @code{yypull_parse} and what it returns.
 * Parser Function::   How to call @code{yyparse} and what it returns.
 * Push Parser Function::  How to call @code{yypush_parse} and what it returns.
 * Pull Parser Function::  How to call @code{yypull_parse} and what it returns.

-* Parser Create Function::  How to call @code{yypstate_new} and what it 
+* Parser Create Function::  How to call @code{yypstate_new} and what it

                         returns.
                         returns.

-* Parser Delete Function::  How to call @code{yypstate_delete} and what it 
+* Parser Delete Function::  How to call @code{yypstate_delete} and what it

                         returns.
 * Lexical::           You must supply a function @code{yylex}
                         which reads tokens.
                         returns.
 * Lexical::           You must supply a function @code{yylex}
                         which reads tokens.


@@ -5224,13 +5309,16 @@ exp: @dots{}    @{ @dots{}; *randomness += 1; @dots{} @}
 @section The Push Parser Function @code{yypush_parse}
 @findex yypush_parse
 
 @section The Push Parser Function @code{yypush_parse}
 @findex yypush_parse
 

-You call the function @code{yypush_parse} to parse a single token.  This 
-function is available if either the @code{%define push_pull "push"} or 
-@code{%define push_pull "both"} declaration is used.  
+(The current push parsing interface is experimental and may evolve.
+More user feedback will help to stabilize it.)
+
+You call the function @code{yypush_parse} to parse a single token.  This
+function is available if either the @code{%define api.push_pull "push"} or
+@code{%define api.push_pull "both"} declaration is used.

 @xref{Push Decl, ,A Push Parser}.
 
 @deftypefun int yypush_parse (yypstate *yyps)
 @xref{Push Decl, ,A Push Parser}.
 
 @deftypefun int yypush_parse (yypstate *yyps)

-The value returned by @code{yypush_parse} is the same as for yyparse with the 
+The value returned by @code{yypush_parse} is the same as for yyparse with the

 following exception.  @code{yypush_parse} will return YYPUSH_MORE if more input
 is required to finish parsing the grammar.
 @end deftypefun
 following exception.  @code{yypush_parse} will return YYPUSH_MORE if more input
 is required to finish parsing the grammar.
 @end deftypefun


@@ -5239,9 +5327,12 @@ is required to finish parsing the grammar.
 @section The Pull Parser Function @code{yypull_parse}
 @findex yypull_parse
 
 @section The Pull Parser Function @code{yypull_parse}
 @findex yypull_parse
 

-You call the function @code{yypull_parse} to parse the rest of the input 
-stream.  This function is available if the @code{%define push_pull "both"} 
-declaration is used.  
+(The current push parsing interface is experimental and may evolve.
+More user feedback will help to stabilize it.)
+
+You call the function @code{yypull_parse} to parse the rest of the input
+stream.  This function is available if the @code{%define api.push_pull "both"}
+declaration is used.

 @xref{Push Decl, ,A Push Parser}.
 
 @deftypefun int yypull_parse (yypstate *yyps)
 @xref{Push Decl, ,A Push Parser}.
 
 @deftypefun int yypull_parse (yypstate *yyps)


@@ -5252,23 +5343,31 @@ The value returned by @code{yypull_parse} is the same as for @code{yyparse}.
 @section The Parser Create Function @code{yystate_new}
 @findex yypstate_new
 
 @section The Parser Create Function @code{yystate_new}
 @findex yypstate_new
 

-You call the function @code{yypstate_new} to create a new parser instance.  
-This function is available if either the @code{%define push_pull "push"} or 
-@code{%define push_pull "both"} declaration is used.  
+(The current push parsing interface is experimental and may evolve.
+More user feedback will help to stabilize it.)
+
+You call the function @code{yypstate_new} to create a new parser instance.
+This function is available if either the @code{%define api.push_pull "push"} or
+@code{%define api.push_pull "both"} declaration is used.

 @xref{Push Decl, ,A Push Parser}.
 
 @deftypefun yypstate *yypstate_new (void)
 The fuction will return a valid parser instance if there was memory available
 @xref{Push Decl, ,A Push Parser}.
 
 @deftypefun yypstate *yypstate_new (void)
 The fuction will return a valid parser instance if there was memory available

-or NULL if no memory was available.
+or 0 if no memory was available.
+In impure mode, it will also return 0 if a parser instance is currently
+allocated.

 @end deftypefun
 
 @node Parser Delete Function
 @section The Parser Delete Function @code{yystate_delete}
 @findex yypstate_delete
 
 @end deftypefun
 
 @node Parser Delete Function
 @section The Parser Delete Function @code{yystate_delete}
 @findex yypstate_delete
 

+(The current push parsing interface is experimental and may evolve.
+More user feedback will help to stabilize it.)
+

 You call the function @code{yypstate_delete} to delete a parser instance.
 You call the function @code{yypstate_delete} to delete a parser instance.

-function is available if either the @code{%define push_pull "push"} or 
-@code{%define push_pull "both"} declaration is used.  
+function is available if either the @code{%define api.push_pull "push"} or
+@code{%define api.push_pull "both"} declaration is used.

 @xref{Push Decl, ,A Push Parser}.
 
 @deftypefun void yypstate_delete (yypstate *yyps)
 @xref{Push Decl, ,A Push Parser}.
 
 @deftypefun void yypstate_delete (yypstate *yyps)


@@ -5456,7 +5555,7 @@ The data type of @code{yylloc} has the name @code{YYLTYPE}.
 @node Pure Calling
 @subsection Calling Conventions for Pure Parsers
 
 @node Pure Calling
 @subsection Calling Conventions for Pure Parsers
 

-When you use the Bison declaration @code{%pure-parser} to request a
+When you use the Bison declaration @code{%define api.pure} to request a

 pure, reentrant parser, the global communication variables @code{yylval}
 and @code{yylloc} cannot be used.  (@xref{Pure Decl, ,A Pure (Reentrant)
 Parser}.)  In such parsers the two global variables are replaced by
 pure, reentrant parser, the global communication variables @code{yylval}
 and @code{yylloc} cannot be used.  (@xref{Pure Decl, ,A Pure (Reentrant)
 Parser}.)  In such parsers the two global variables are replaced by


@@ -5507,7 +5606,7 @@ int yylex   (int *nastiness);
 int yyparse (int *nastiness, int *randomness);
 @end example
 
 int yyparse (int *nastiness, int *randomness);
 @end example
 

-If @code{%pure-parser} is added:
+If @code{%define api.pure} is added:

 
 @example
 int yylex   (YYSTYPE *lvalp, int *nastiness);
 
 @example
 int yylex   (YYSTYPE *lvalp, int *nastiness);


@@ -5515,7 +5614,7 @@ int yyparse (int *nastiness, int *randomness);
 @end example
 
 @noindent
 @end example
 
 @noindent

-and finally, if both @code{%pure-parser} and @code{%locations} are used:
+and finally, if both @code{%define api.pure} and @code{%locations} are used:

 
 @example
 int yylex   (YYSTYPE *lvalp, YYLTYPE *llocp, int *nastiness);
 
 @example
 int yylex   (YYSTYPE *lvalp, YYLTYPE *llocp, int *nastiness);


@@ -5581,7 +5680,7 @@ 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}
 parsers, but not for the Yacc parser, for historical reasons.  I.e., if
 an access to the current location.
 This is indeed the case for the @acronym{GLR}
 parsers, but not for the Yacc parser, for historical reasons.  I.e., if

-@samp{%locations %pure-parser} is passed then the prototypes for
+@samp{%locations %define api.pure} is passed then the prototypes for

 @code{yyerror} are:
 
 @example
 @code{yyerror} are:
 
 @example


@@ -5599,13 +5698,14 @@ void yyerror (int *nastiness, char const *msg);  /* GLR parsers.   */
 Finally, @acronym{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
 Finally, @acronym{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{%pure-parser} are pure.  I.e.:
+@code{%define api.pure} are pure.
+I.e.:

 
 @example
 /* Location tracking.  */
 %locations
 /* Pure yylex.  */
 
 @example
 /* Location tracking.  */
 %locations
 /* Pure yylex.  */

-%pure-parser
+%define api.pure

 %lex-param   @{int *nastiness@}
 /* Pure yyparse.  */
 %parse-param @{int *nastiness@}
 %lex-param   @{int *nastiness@}
 /* Pure yyparse.  */
 %parse-param @{int *nastiness@}


@@ -7098,9 +7198,9 @@ useless: STR;
 @command{bison} reports:
 
 @example
 @command{bison} reports:
 
 @example

-calc.y: warning: 1 useless nonterminal and 1 useless rule
-calc.y:11.1-7: warning: useless nonterminal: useless
-calc.y:11.10-12: warning: useless rule: useless: STR
+calc.y: warning: 1 nonterminal and 1 rule useless in grammar
+calc.y:11.1-7: warning: nonterminal useless in grammar: useless
+calc.y:11.10-12: warning: rule useless in grammar: useless: STR

 calc.y: conflicts: 7 shift/reduce
 @end example
 
 calc.y: conflicts: 7 shift/reduce
 @end example
 


@@ -7139,17 +7239,17 @@ State 11 conflicts: 4 shift/reduce
 The next section reports useless tokens, nonterminal and rules.  Useless
 nonterminals and rules are removed in order to produce a smaller parser,
 but useless tokens are preserved, since they might be used by the
 The next section reports useless tokens, nonterminal and rules.  Useless
 nonterminals and rules are removed in order to produce a smaller parser,
 but useless tokens are preserved, since they might be used by the

-scanner (note the difference between ``useless'' and ``not used''
+scanner (note the difference between ``useless'' and ``unused''

 below):
 
 @example
 below):
 
 @example

-Useless nonterminals:
+Nonterminals useless in grammar:

    useless
 
    useless
 

-Terminals which are not used:
+Terminals unused in grammar:

    STR
 
    STR
 

-Useless rules:
+Rules useless in grammar:

 #6     useless: STR;
 @end example
 
 #6     useless: STR;
 @end example
 


@@ -7387,7 +7487,7 @@ with some set of possible lookahead tokens.  When run with
 @example
 state 8
 
 @example
 state 8
 

-    exp  ->  exp . '+' exp  [$, '+', '-', '/']   (rule 1)
+    exp  ->  exp . '+' exp   (rule 1)

     exp  ->  exp '+' exp .  [$, '+', '-', '/']   (rule 1)
     exp  ->  exp . '-' exp   (rule 2)
     exp  ->  exp . '*' exp   (rule 3)
     exp  ->  exp '+' exp .  [$, '+', '-', '/']   (rule 1)
     exp  ->  exp . '-' exp   (rule 2)
     exp  ->  exp . '*' exp   (rule 3)


@@ -7676,6 +7776,46 @@ traditional Yacc grammars.  If your grammar uses a Bison extension
 like @samp{%glr-parser}, Bison might not be Yacc-compatible even if
 this option is specified.
 
 like @samp{%glr-parser}, Bison might not be Yacc-compatible even if
 this option is specified.
 

+@item -W
+@itemx --warnings
+Output warnings falling in @var{category}.  @var{category} can be one
+of:
+@table @code
+@item midrule-values
+Warn about mid-rule values that are set but not used within any of the actions
+of the parent rule.
+For example, warn about unused @code{$2} in:
+
+@example
+exp: '1' @{ $$ = 1; @} '+' exp @{ $$ = $1 + $4; @};
+@end example
+
+Also warn about mid-rule values that are used but not set.
+For example, warn about unset @code{$$} in the mid-rule action in:
+
+@example
+ exp: '1' @{ $1 = 1; @} '+' exp @{ $$ = $2 + $4; @};
+@end example
+
+These warnings are not enabled by default since they sometimes prove to
+be false alarms in existing grammars employing the Yacc constructs
+@code{$0} or @code{$-@var{n}} (where @var{n} is some positive integer).
+
+
+@item yacc
+Incompatibilities with @acronym{POSIX} Yacc.
+
+@item all
+All the warnings.
+@item none
+Turn off all the warnings.
+@item error
+Treat warnings as errors.
+@end table
+
+A category can be turned off by prefixing its name with @samp{no-}.  For
+instance, @option{-Wno-syntax} will hide the warnings about unused
+variables.

 @end table
 
 @noindent
 @end table
 
 @noindent


@@ -7692,7 +7832,7 @@ already defined, so that the debugging facilities are compiled.
 @itemx --language=@var{language}
 Specify the programming language for the generated parser, as if
 @code{%language} was specified (@pxref{Decl Summary, , Bison Declaration
 @itemx --language=@var{language}
 Specify the programming language for the generated parser, as if
 @code{%language} was specified (@pxref{Decl Summary, , Bison Declaration

-Summary}).  Currently supported languages include C and C++.
+Summary}).  Currently supported languages include C, C++, and Java.

 @var{language} is case-insensitive.
 
 @item --locations
 @var{language} is case-insensitive.
 
 @item --locations


@@ -7736,14 +7876,15 @@ Pretend that @code{%token-table} was specified.  @xref{Decl Summary}.
 Adjust the output:
 
 @table @option
 Adjust the output:
 
 @table @option

-@item -d
-@itemx --defines
+@item --defines[=@var{file}]

 Pretend that @code{%defines} was specified, i.e., write an extra output
 file containing macro definitions for the token type names defined in
 the grammar, as well as a few other declarations.  @xref{Decl Summary}.
 
 Pretend that @code{%defines} was specified, i.e., write an extra output
 file containing macro definitions for the token type names defined in
 the grammar, as well as a few other declarations.  @xref{Decl Summary}.
 

-@item --defines=@var{defines-file}
-Same as above, but save in the file @var{defines-file}.
+@item -d
+This is the same as @code{--defines} except @code{-d} does not accept a
+@var{file} argument since POSIX Yacc requires that @code{-d} can be bundled
+with other short options.

 
 @item -b @var{file-prefix}
 @itemx --file-prefix=@var{prefix}
 
 @item -b @var{file-prefix}
 @itemx --file-prefix=@var{prefix}


@@ -7769,6 +7910,9 @@ Implies @code{state} and augments the description of the automaton with
 the full set of items for each state, instead of its core only.
 @end table
 
 the full set of items for each state, instead of its core only.
 @end table
 

+@item --report-file=@var{file}
+Specify the @var{file} for the verbose description.
+

 @item -v
 @itemx --verbose
 Pretend that @code{%verbose} was specified, i.e., write an extra output
 @item -v
 @itemx --verbose
 Pretend that @code{%verbose} was specified, i.e., write an extra output


@@ -7782,17 +7926,23 @@ Specify the @var{file} for the parser file.
 The other output files' names are constructed from @var{file} as
 described under the @samp{-v} and @samp{-d} options.
 
 The other output files' names are constructed from @var{file} as
 described under the @samp{-v} and @samp{-d} options.
 

-@item -g
+@item -g[@var{file}]
+@itemx --graph[=@var{file}]

 Output a graphical representation of the @acronym{LALR}(1) grammar
 automaton computed by Bison, in @uref{http://www.graphviz.org/, Graphviz}
 @uref{http://www.graphviz.org/doc/info/lang.html, @acronym{DOT}} format.
 Output a graphical representation of the @acronym{LALR}(1) grammar
 automaton computed by Bison, in @uref{http://www.graphviz.org/, Graphviz}
 @uref{http://www.graphviz.org/doc/info/lang.html, @acronym{DOT}} format.

-If the grammar file is @file{foo.y}, the output file will
-be @file{foo.dot}.
-
-@item --graph=@var{graph-file}
-The behavior of @var{--graph} is the same than @samp{-g}.  The only
-difference is that it has an optional argument which is the name of
-the output graph file.
+@code{@var{file}} is optional.
+If omitted and the grammar file is @file{foo.y}, the output file will be
+@file{foo.dot}.
+
+@item -x[@var{file}]
+@itemx --xml[=@var{file}]
+Output an XML report of the @acronym{LALR}(1) automaton computed by Bison.
+@code{@var{file}} is optional.
+If omitted and the grammar file is @file{foo.y}, the output file will be
+@file{foo.xml}.
+(The current XML schema is experimental and may evolve.
+More user feedback will help to stabilize it.)

 @end table
 
 @node Option Cross Key
 @end table
 
 @node Option Cross Key


@@ -7804,20 +7954,7 @@ the corresponding short option.
 
 @multitable {@option{--defines=@var{defines-file}}} {@option{-b @var{file-prefix}XXX}}
 @headitem Long Option @tab Short Option
 
 @multitable {@option{--defines=@var{defines-file}}} {@option{-b @var{file-prefix}XXX}}
 @headitem Long Option @tab Short Option

-@item @option{--debug}                      @tab @option{-t}
-@item @option{--defines=@var{defines-file}} @tab @option{-d}
-@item @option{--file-prefix=@var{prefix}}   @tab @option{-b @var{file-prefix}}
-@item @option{--graph=@var{graph-file}}     @tab @option{-d}
-@item @option{--help}                       @tab @option{-h}
-@item @option{--name-prefix=@var{prefix}}   @tab @option{-p @var{name-prefix}}
-@item @option{--no-lines}                   @tab @option{-l}
-@item @option{--output=@var{outfile}}       @tab @option{-o @var{outfile}}
-@item @option{--print-localedir}            @tab
-@item @option{--print-datadir}              @tab
-@item @option{--token-table}                @tab @option{-k}
-@item @option{--verbose}                    @tab @option{-v}
-@item @option{--version}                    @tab @option{-V}
-@item @option{--yacc}                       @tab @option{-y}
+@include cross-options.texi

 @end multitable
 
 @node Yacc Library
 @end multitable
 
 @node Yacc Library


@@ -8066,7 +8203,7 @@ described by @var{m}.
 
 The parser invokes the scanner by calling @code{yylex}.  Contrary to C
 parsers, C++ parsers are always pure: there is no point in using the
 
 The parser invokes the scanner by calling @code{yylex}.  Contrary to C
 parsers, C++ parsers are always pure: there is no point in using the

-@code{%pure-parser} directive.  Therefore the interface is as follows.
+@code{%define api.pure} directive.  Therefore the interface is as follows.

 
 @deftypemethod {parser} {int} yylex (semantic_value_type& @var{yylval}, location_type& @var{yylloc}, @var{type1} @var{arg1}, ...)
 Return the next token.  Its type is the return value, its semantic
 
 @deftypemethod {parser} {int} yylex (semantic_value_type& @var{yylval}, location_type& @var{yylloc}, @var{type1} @var{arg1}, ...)
 Return the next token.  Its type is the return value, its semantic


@@ -8596,6 +8733,9 @@ main (int argc, char *argv[])
 @c - %language "Java"
 @c - initial action
 
 @c - %language "Java"
 @c - initial action
 

+(The current Java interface is experimental and may evolve.
+More user feedback will help to stabilize it.)
+

 The Java parser skeletons are selected using a language directive,
 @samp{%language "Java"}, or the synonymous command-line option
 @option{--language=java}.
 The Java parser skeletons are selected using a language directive,
 @samp{%language "Java"}, or the synonymous command-line option
 @option{--language=java}.


@@ -8607,9 +8747,9 @@ in an arbitrary Java package using a @samp{%define package} section.
 
 The parser class defines an inner class, @code{Location}, that is used
 for location tracking.  If the parser is pure, it also defines an
 
 The parser class defines an inner class, @code{Location}, that is used
 for location tracking.  If the parser is pure, it also defines an

-inner interface, @code{Lexer}; see~@ref{Java Scanner Interface} for the
+inner interface, @code{Lexer}; see @ref{Java Scanner Interface} for the

 meaning of pure parsers when the Java language is chosen.  Other than
 meaning of pure parsers when the Java language is chosen.  Other than

-these inner class/interface, and the members described in~@ref{Java
+these inner class/interface, and the members described in @ref{Java

 Parser Interface}, all the other members and fields are preceded
 with a @code{yy} prefix to avoid clashes with user code.
 
 Parser Interface}, all the other members and fields are preceded
 with a @code{yy} prefix to avoid clashes with user code.
 


@@ -8764,9 +8904,14 @@ Contrary to C parsers, Java parsers do not use global variables; the
 state of the parser is always local to an instance of the parser class.
 Therefore, all Java parsers are ``pure'', and the @code{%pure-parser}
 directive does not do anything when used in Java.
 state of the parser is always local to an instance of the parser class.
 Therefore, all Java parsers are ``pure'', and the @code{%pure-parser}
 directive does not do anything when used in Java.

+@c FIXME: But a bit farther it is stated that
+@c  If @code{%pure-parser} is not specified, the lexer interface
+@c  resides in the same class (@code{YYParser}) as the Bison-generated
+@c  parser. The fields and methods that are provided to
+@c  this end are as follows.

 
 The scanner always resides in a separate class than the parser.
 
 The scanner always resides in a separate class than the parser.

-Still, Java also two possible ways to interface a Bison-generated Java
+Still, there are two possible ways to interface a Bison-generated Java

 parser with a scanner, that is, the scanner may reside in a separate file
 than the Bison grammar, or in the same file.  The interface
 to the scanner is similar in the two cases.
 parser with a scanner, that is, the scanner may reside in a separate file
 than the Bison grammar, or in the same file.  The interface
 to the scanner is similar in the two cases.


@@ -8777,7 +8922,7 @@ to pass parameters from the parser constructor to the scanner constructor,
 specify them with @code{%lex-param}; they are passed before
 @code{%parse-param}s to the constructor.
 
 specify them with @code{%lex-param}; they are passed before
 @code{%parse-param}s to the constructor.
 

-In the second case, the scanner has to implement interface @code{Lexer},
+In the second case, the scanner has to implement the @code{Lexer} interface,

 which is defined within the parser class (e.g., @code{YYParser.Lexer}).
 The constructor of the parser object will then accept an object
 implementing the interface; @code{%lex-param} is not used in this
 which is defined within the parser class (e.g., @code{YYParser.Lexer}).
 The constructor of the parser object will then accept an object
 implementing the interface; @code{%lex-param} is not used in this


@@ -8810,21 +8955,19 @@ The return type can be changed using @samp{%define "position_type"
 @end deftypemethod
 
 @deftypemethod {Lexer} {Object} getLVal ()
 @end deftypemethod
 
 @deftypemethod {Lexer} {Object} getLVal ()

-Return respectively the first position of the last token that yylex
-returned, and the first position beyond it.
+Return the semantical value of the last token that yylex returned.

 
 The return type can be changed using @samp{%define "stype"
 "@var{class-name}".}
 @end deftypemethod
 
 
 
 The return type can be changed using @samp{%define "stype"
 "@var{class-name}".}
 @end deftypemethod
 
 

-If @code{%pure-parser} is not specified, the lexer interface
-resides in the same class (@code{YYParser}) as the Bison-generated
-parser. The fields and methods that are provided to
-this end are as follows.
+The lexer interface resides in the same class (@code{YYParser}) as the
+Bison-generated parser.
+The fields and methods that are provided to this end are as follows.

 
 @deftypemethod {YYParser} {void} error (Location @var{l}, String @var{m})
 
 @deftypemethod {YYParser} {void} error (Location @var{l}, String @var{m})

-As explained in @pxref{Java Parser Interface}, this method is defined
+As already explained (@pxref{Java Parser Interface}), this method is defined

 by the user to emit an error message.  The first parameter is not used
 unless location tracking is active.  Its type can be changed using
 @samp{%define "location_type" "@var{class-name}".}
 by the user to emit an error message.  The first parameter is not used
 unless location tracking is active.  Its type can be changed using
 @samp{%define "location_type" "@var{class-name}".}


@@ -8954,7 +9097,7 @@ or
 @display
 My parser includes support for an @samp{#include}-like feature, in
 which case I run @code{yyparse} from @code{yyparse}.  This fails
 @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}.
+although I did specify @code{%define api.pure}.

 @end display
 
 These problems typically come not from Bison itself, but from
 @end display
 
 These problems typically come not from Bison itself, but from


@@ -9516,8 +9659,8 @@ Bison declaration to assign a precedence to a specific rule.
 @end deffn
 
 @deffn {Directive} %pure-parser
 @end deffn
 
 @deffn {Directive} %pure-parser

-Bison declaration to request a pure (reentrant) parser.
-@xref{Pure Decl, ,A Pure (Reentrant) Parser}.
+Deprecated version of @code{%define api.pure} (@pxref{Decl Summary, ,%define}),
+for which Bison is more careful to warn about unreasonable usage.

 @end deffn
 
 @deffn {Directive} %require "@var{version}"
 @end deffn
 
 @deffn {Directive} %require "@var{version}"


@@ -9694,7 +9837,7 @@ Management}.
 
 @deffn {Variable} yynerrs
 Global variable which Bison increments each time it reports a syntax error.
 
 @deffn {Variable} yynerrs
 Global variable which Bison increments each time it reports a syntax error.

-(In a pure parser, it is a local variable within @code{yyparse}. In a 
+(In a pure parser, it is a local variable within @code{yyparse}. In a

 pure push parser, it is a member of yypstate.)
 @xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}.
 @end deffn
 pure push parser, it is a member of yypstate.)
 @xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}.
 @end deffn


@@ -9705,30 +9848,38 @@ parsing.  @xref{Parser Function, ,The Parser Function @code{yyparse}}.
 @end deffn
 
 @deffn {Function} yypstate_delete
 @end deffn
 
 @deffn {Function} yypstate_delete

-The function to delete a parser instance, produced by Bison in push mode; 
+The function to delete a parser instance, produced by Bison in push mode;

 call this function to delete the memory associated with a parser.
 call this function to delete the memory associated with a parser.

-@xref{Parser Delete Function, ,The Parser Delete Function 
+@xref{Parser Delete Function, ,The Parser Delete Function

 @code{yypstate_delete}}.
 @code{yypstate_delete}}.

+(The current push parsing interface is experimental and may evolve.
+More user feedback will help to stabilize it.)

 @end deffn
 
 @deffn {Function} yypstate_new
 @end deffn
 
 @deffn {Function} yypstate_new

-The function to create a parser instance, produced by Bison in push mode; 
+The function to create a parser instance, produced by Bison in push mode;

 call this function to create a new parser.
 call this function to create a new parser.

-@xref{Parser Create Function, ,The Parser Create Function 
+@xref{Parser Create Function, ,The Parser Create Function

 @code{yypstate_new}}.
 @code{yypstate_new}}.

+(The current push parsing interface is experimental and may evolve.
+More user feedback will help to stabilize it.)

 @end deffn
 
 @deffn {Function} yypull_parse
 @end deffn
 
 @deffn {Function} yypull_parse

-The parser function produced by Bison in push mode; call this function to 
-parse the rest of the input stream.  
-@xref{Pull Parser Function, ,The Pull Parser Function 
+The parser function produced by Bison in push mode; call this function to
+parse the rest of the input stream.
+@xref{Pull Parser Function, ,The Pull Parser Function

 @code{yypull_parse}}.
 @code{yypull_parse}}.

+(The current push parsing interface is experimental and may evolve.
+More user feedback will help to stabilize it.)

 @end deffn
 
 @deffn {Function} yypush_parse
 @end deffn
 
 @deffn {Function} yypush_parse

-The parser function produced by Bison in push mode; call this function to 
-parse a single token.  @xref{Push Parser Function, ,The Push Parser Function 
+The parser function produced by Bison in push mode; call this function to
+parse a single token.  @xref{Push Parser Function, ,The Push Parser Function

 @code{yypush_parse}}.
 @code{yypush_parse}}.

+(The current push parsing interface is experimental and may evolve.
+More user feedback will help to stabilize it.)

 @end deffn
 
 @deffn {Macro} YYPARSE_PARAM
 @end deffn
 
 @deffn {Macro} YYPARSE_PARAM