From: Akim Demaille <akim@lrde.epita.fr>
Date: Mon, 2 Jul 2012 07:55:43 +0000 (+0200)
Subject: Merge remote-tracking branch 'origin/maint'
X-Git-Tag: v2.7.90~407
X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/5458913abab5e33938892b0d279f02f3b09d94db

Merge remote-tracking branch 'origin/maint'

* origin/maint:
  NEWS: spell check.
  api.prefix.

Conflicts:
	data/c.m4
	data/glr.cc
	data/lalr1.cc
	doc/bison.texi
---

5458913abab5e33938892b0d279f02f3b09d94db
diff --cc data/c++.m4
index f1468c70,9913a172..4bc6c4c7
--- a/data/c++.m4
+++ b/data/c++.m4
@@@ -105,257 -103,6 +105,257 @@@ m4_map_sep([     b4_token_enum], [
  ## Semantic Values.  ##
  ## ----------------- ##
  
 +# b4_semantic_type_declare
 +# ------------------------
 +# Declare semantic_type.
 +m4_define([b4_semantic_type_declare],
 +[    /// Symbol semantic values.
 +m4_ifdef([b4_stype],
 +[    union semantic_type
 +    {b4_user_stype
 +    };],
 +[m4_if(b4_tag_seen_flag, 0,
 +[[    typedef int semantic_type;]],
- [[    typedef YYSTYPE semantic_type;]])])])
++[[    typedef ]b4_api_PREFIX[STYPE semantic_type;]])])])
 +
 +
 +# b4_public_types_declare
 +# -----------------------
 +# Define the public types: token, semantic value, location, and so forth.
 +# Depending on %define token_lex, may be output in the header or source file.
 +m4_define([b4_public_types_declare],
- [[#ifndef YYSTYPE
++[[#ifndef ]b4_api_PREFIX[STYPE
 +]b4_semantic_type_declare[
 +#else
-     typedef YYSTYPE semantic_type;
++    typedef ]b4_api_PREFIX[STYPE semantic_type;
 +#endif]b4_locations_if([
 +    /// Symbol locations.
 +    typedef b4_percent_define_get([[location_type]],
 +                                  [[location]]) location_type;])[
 +
 +    /// Syntax errors thrown from user actions.
 +    struct syntax_error : std::runtime_error
 +    {
 +      syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m);]b4_locations_if([
 +      location_type location;])[
 +    };
 +
 +    /// Tokens.
 +    struct token
 +    {
 +      ]b4_token_enums(b4_tokens)[
 +    };
 +
 +    /// Token type.
 +    typedef token::yytokentype token_type;
 +
 +    /// A complete symbol, with its type.
 +    template <typename Exact>
 +    struct symbol_base_type
 +    {
 +      /// Default constructor.
 +      inline symbol_base_type ();
 +
 +      /// Constructor.]b4_locations_if([
 +      inline symbol_base_type (const location_type& l)])[;
 +      inline symbol_base_type (]b4_args(
 +        [const semantic_type& v],
 +        b4_locations_if([const location_type& l]))[);
 +
 +      /// Return this with its exact type.
 +      const Exact& self () const;
 +      Exact& self ();
 +
 +      /// Return the type of this symbol.
 +      int type_get () const;
 +
 +      /// The semantic value.
 +      semantic_type value;]b4_locations_if([
 +
 +      /// The location.
 +      location_type location;])[
 +    };
 +
 +    /// External form of a symbol: its type and attributes.
 +    struct symbol_type : symbol_base_type<symbol_type>
 +    {
 +      /// The parent class.
 +      typedef symbol_base_type<symbol_type> super_type;
 +
 +      /// Default constructor.
 +      inline symbol_type ();
 +
 +      /// Constructor for tokens with semantic value.
 +      inline symbol_type (]b4_args([token_type t],
 +                                   [const semantic_type& v],
 +                                   b4_locations_if([const location_type& l]))[);
 +
 +      /// Constructor for valueless tokens.
 +      inline symbol_type (]b4_args([token_type t],
 +                                   b4_locations_if([const location_type& l]))[);
 +
 +      /// The symbol type.
 +      int type;
 +
 +      /// The symbol type.
 +      inline int type_get_ () const;
 +
 +      /// The token.
 +      inline token_type token () const;
 +    };
 +]b4_symbol_constructor_declare])
 +
 +
 +# b4_public_types_define
 +# ----------------------
 +# Provide the implementation needed by the public types.
 +m4_define([b4_public_types_define],
 +[[  inline
 +  ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m)
 +    : std::runtime_error (m)]b4_locations_if([
 +    , location (l)])[
 +  {}
 +
 +  // symbol_base_type.
 +  template <typename Exact>
 +  inline
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type ()
 +    : value()]b4_locations_if([
 +    , location()])[
 +  {
 +  }]b4_locations_if([[
 +
 +  template <typename Exact>
 +  inline
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const location_type& l)
 +    : value()
 +    , location(l)
 +  {
 +  }]])[
 +
 +  template <typename Exact>
 +  inline
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (]b4_args(
 +          [const semantic_type& v],
 +          b4_locations_if([const location_type& l]))[)
 +    : value(v)]b4_locations_if([
 +    , location(l)])[
 +  {
 +  }
 +
 +  template <typename Exact>
 +  inline
 +  const Exact&
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::self () const
 +  {
 +    return static_cast<const Exact&>(*this);
 +  }
 +
 +  template <typename Exact>
 +  inline
 +  Exact&
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::self ()
 +  {
 +    return static_cast<Exact&>(*this);
 +  }
 +
 +  template <typename Exact>
 +  inline
 +  int
 +  ]b4_parser_class_name[::symbol_base_type<Exact>::type_get () const
 +  {
 +    return self ().type_get_ ();
 +  }
 +
 +  // symbol_type.
 +  inline
 +  ]b4_parser_class_name[::symbol_type::symbol_type ()
 +    : super_type ()
 +    , type ()
 +  {
 +  }
 +
 +  inline
 +  ]b4_parser_class_name[::symbol_type::symbol_type (]b4_args(
 +                [token_type t],
 +                b4_locations_if([const location_type& l]))[)
 +    : super_type (]b4_locations_if([l])[)
 +    , type (yytranslate_ (t))
 +  {
 +  }
 +
 +  inline
 +  ]b4_parser_class_name[::symbol_type::symbol_type (]b4_args(
 +                 [token_type t],
 +                 [const semantic_type& v],
 +                 b4_locations_if([const location_type& l]))[)
 +    : super_type (v]b4_locations_if([, l])[)
 +    , type (yytranslate_ (t))
 +  {
 +  }
 +
 +  inline
 +  int
 +  ]b4_parser_class_name[::symbol_type::type_get_ () const
 +  {
 +    return type;
 +  }
 +]b4_lex_symbol_if([[
 +  inline
 +  ]b4_parser_class_name[::token_type
 +  ]b4_parser_class_name[::symbol_type::token () const
 +  {
 +    // YYTOKNUM[NUM] -- (External) token number corresponding to the
 +    // (internal) symbol number NUM (which must be that of a token).  */
 +    static
 +    const ]b4_int_type_for([b4_toknum])[
 +    yytoken_number_[] =
 +    {
 +  ]b4_toknum[
 +    };
 +    return static_cast<token_type> (yytoken_number_[type]);
 +  }
 +]])[]dnl
 +b4_symbol_constructor_define])
 +
 +
 +# b4_symbol_constructor_declare
 +# b4_symbol_constructor_define
 +# -----------------------------
 +# Declare/define symbol constructors for all the value types.
 +# Use at class-level.  Redefined in variant.hh.
 +m4_define([b4_symbol_constructor_declare], [])
 +m4_define([b4_symbol_constructor_define], [])
 +
 +
 +# b4_yytranslate_define
 +# ---------------------
 +# Define yytranslate_.  Sometimes used in the header file,
 +# sometimes in the cc file.
 +m4_define([b4_yytranslate_define],
 +[[  // Symbol number corresponding to token number t.
 +  ]b4_parser_class_name[::token_number_type
 +  ]b4_parser_class_name[::yytranslate_ (]b4_lex_symbol_if([token_type],
 +                                                          [int])[ t)
 +  {
 +    static
 +    const token_number_type
 +    translate_table[] =
 +    {
 +]b4_translate[
 +    };
 +    const unsigned int user_token_number_max_ = ]b4_user_token_number_max[;
 +    const token_number_type undef_token_ = ]b4_undef_token_number[;
 +
 +    if (static_cast<int>(t) <= yyeof_)
 +      return yyeof_;
 +    else if (static_cast<unsigned int> (t) <= user_token_number_max_)
 +      return translate_table[t];
 +    else
 +      return undef_token_;
 +  }
 +]])
 +
  
  # b4_lhs_value([TYPE])
  # --------------------
diff --cc data/c.m4
index f7179e91,0b2699a1..831274cb
--- a/data/c.m4
+++ b/data/c.m4
@@@ -267,18 -245,18 +280,18 @@@ m4_define([b4_token_enum]
  # Output the definition of the tokens (if there are) as enums.
  m4_define([b4_token_enums],
  [m4_if([$#$1], [1], [],
- [/* Tokens.  */
- #ifndef YYTOKENTYPE
- # define YYTOKENTYPE
+ [[/* Tokens.  */
+ #ifndef ]b4_api_PREFIX[TOKENTYPE
+ # define ]b4_api_PREFIX[TOKENTYPE
     /* Put the tokens into the symbol table, so that GDB and other debuggers
        know about them.  */
-    enum yytokentype {
- m4_map_sep([     b4_token_enum], [,
+    enum ]b4_api_prefix[tokentype {
+ ]m4_map_sep([     b4_token_enum], [,
  ],
 -	   [$@])[
 -   };
 +           [$@])
-    };
++   };[
  #endif
- ])])
+ ]])])
  
  
  # b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
diff --cc data/lalr1.cc
index 7ad30e5c,337af10a..76104de8
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@@ -725,32 -593,32 +725,32 @@@ m4_popdef([b4_at_dollar])])dn
        goto yydefault;
  
      /* Read a lookahead token.  */
 -    if (yychar == yyempty_)
 -      {
 -	YYCDEBUG << "Reading a token: ";
 -	yychar = ]b4_c_function_call([yylex], [int],
 -				     [b4_api_PREFIX[STYPE*], [&yylval]][]dnl
 -b4_locations_if([, [[location*], [&yylloc]]])dnl
 -m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
 -      }
 -
 -
 -    /* Convert token to internal form.  */
 -    if (yychar <= yyeof_)
 -      {
 -	yychar = yytoken = yyeof_;
 -	YYCDEBUG << "Now at end of input." << std::endl;
 -      }
 -    else
 +    if (yyempty)
        {
 -	yytoken = yytranslate_ (yychar);
 -	YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
 +        YYCDEBUG << "Reading a token: ";
 +        try
 +        {
 +]b4_lex_symbol_if(
 +[          yyla = b4_c_function_call([yylex], [symbol_type],
 +                                     m4_ifdef([b4_lex_param], b4_lex_param));],
 +[          yyla.type = yytranslate_ (b4_c_function_call([yylex], [int],
-                                      [[YYSTYPE*], [&yyla.value]][]dnl
++                                     [b4_api_PREFIX[STYPE*], [&yyla.value]][]dnl
 +b4_locations_if([, [[location*], [&yyla.location]]])dnl
 +m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
 +        }
 +        catch (const syntax_error& yyexc)
 +        {
 +          error (yyexc);
 +          goto yyerrlab1;
 +        }
 +        yyempty = false;
        }
 +    YY_SYMBOL_PRINT ("Next token is", yyla);
  
 -    /* If the proper action on seeing token YYTOKEN is to reduce or to
 -       detect an error, take that action.  */
 -    yyn += yytoken;
 -    if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
 +    /* If the proper action on seeing token YYLA.TYPE is to reduce or
 +       to detect an error, take that action.  */
 +    yyn += yyla.type;
 +    if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
        goto yydefault;
  
      /* Reduce or error.  */
diff --cc doc/bison.texi
index d1223bdc,fbe780cd..085c5a96
--- a/doc/bison.texi
+++ b/doc/bison.texi
@@@ -5398,63 -5300,24 +5398,77 @@@ Summary,,%skeleton})
  Unaccepted @var{variable}s produce an error.
  Some of the accepted @var{variable}s are:
  
 -@itemize @bullet
 +@table @code
 +@c ================================================== api.namespace
 +@item api.namespace
 +@findex %define api.namespace
 +@itemize
 +@item Languages(s): C++
 +
 +@item Purpose: Specify the namespace for the parser class.
 +For example, if you specify:
 +
 +@example
 +%define api.namespace "foo::bar"
 +@end example
 +
 +Bison uses @code{foo::bar} verbatim in references such as:
 +
 +@example
 +foo::bar::parser::semantic_type
 +@end example
 +
 +However, to open a namespace, Bison removes any leading @code{::} and then
 +splits on any remaining occurrences:
 +
 +@example
 +namespace foo @{ namespace bar @{
 +  class position;
 +  class location;
 +@} @}
 +@end example
 +
 +@item Accepted Values:
 +Any absolute or relative C++ namespace reference without a trailing
 +@code{"::"}.  For example, @code{"foo"} or @code{"::foo::bar"}.
 +
 +@item Default Value:
 +The value specified by @code{%name-prefix}, which defaults to @code{yy}.
 +This usage of @code{%name-prefix} is for backward compatibility and can
 +be confusing since @code{%name-prefix} also specifies the textual prefix
 +for the lexical analyzer function.  Thus, if you specify
 +@code{%name-prefix}, it is best to also specify @samp{%define
 +api.namespace} so that @code{%name-prefix} @emph{only} affects the
 +lexical analyzer function.  For example, if you specify:
 +
 +@example
 +%define api.namespace "foo"
 +%name-prefix "bar::"
 +@end example
 +
 +The parser namespace is @code{foo} and @code{yylex} is referenced as
 +@code{bar::lex}.
 +@end itemize
 +@c namespace
 +
 +
+ @c ================================================== api.prefix
 -@item @code{api.prefix}
++@item api.prefix
+ @findex %define api.prefix
+ 
+ @itemize @bullet
+ @item Language(s): All
+ 
+ @item Purpose: Rename exported symbols
+ @xref{Multiple Parsers, ,Multiple Parsers in the Same Program}.
+ 
+ @item Accepted Values: String
+ 
+ @item Default Value: @code{yy}
+ @end itemize
  
  @c ================================================== api.pure
 -@item @code{api.pure}
 +@item api.pure
  @findex %define api.pure
  
  @itemize @bullet
diff --cc src/getargs.c
index 8596958c,599cbbad..dadcbbb9
--- a/src/getargs.c
+++ b/src/getargs.c
@@@ -302,13 -309,13 +302,14 @@@ Parser:\n
    -L, --language=LANGUAGE          specify the output programming language\n\
                                     (this is an experimental feature)\n\
    -S, --skeleton=FILE              specify the skeleton to use\n\
 -  -t, --debug                      instrument the parser for debugging\n\
 +  -t, --debug                      instrument the parser for tracing\n\
 +                                   same as `-Dparse.trace'\n\
        --locations                  enable location support\n\
-   -D, --define=NAME[=VALUE]        similar to `%define NAME \"VALUE\"'\n\
-   -F, --force-define=NAME[=VALUE]  override `%define NAME \"VALUE\"'\n\
+   -D, --define=NAME[=VALUE]        similar to '%define NAME \"VALUE\"'\n\
+   -F, --force-define=NAME[=VALUE]  override '%define NAME \"VALUE\"'\n\
    -p, --name-prefix=PREFIX         prepend PREFIX to the external symbols\n\
-   -l, --no-lines                   don't generate `#line' directives\n\
+                                    deprecated by '-Dapi.prefix=PREFIX'\n\
+   -l, --no-lines                   don't generate '#line' directives\n\
    -k, --token-table                include a table of token names\n\
  \n\
  "), stdout);