lalr1.cc: support move semantics

Modern C++ (i.e., C++11 and later) introduced "move only" types: types such
as std::unique_ptr<T> that can never be duplicated.  They must never be
copied (by assignments and constructors), they must be "moved".  The
implementation of lalr1.cc used to copy symbols (including their semantic
values).  This commit ensures that values are only moved in modern C++, yet
remain compatible with C++98/C++03.

Suggested by Frank Heckenbach, who provided a full implementation on
top of C++17's std::variant.
See http://lists.gnu.org/archive/html/bug-bison/2018-03/msg00002.html,
and https://lists.gnu.org/archive/html/bison-patches/2018-04/msg00002.html.

Symbols (terminal/non terminal) are handled by several functions that used
to take const-refs, which resulted eventually in a copy pushed on the stack.
With modern C++ (C++11 and later) the callers must use std::move, and the
callees must take their arguments as rvalue refs (foo&&).  In order to avoid
duplicating these functions to support both legacy C++ and modern C++, let's
introduce macros (YY_MOVE, YY_RVREF, etc.)  that rely on copy-semantics for
C++98/03, and move-semantics for modern C++.

That's easy for inner types, when the parser's functions pass arguments to
each other.  Functions facing the user (make_NUMBER, make_STRING, etc.)
should support both rvalue-refs (for instance to support move-only types:
make_INT (std::make_unique<int> (1))), and lvalue-refs (so that we can pass
a variable: make_INT (my_int)).  To avoid the multiplication of the
signatures (there is also the location), let's take the argument by value.

See:
https://lists.gnu.org/archive/html/bison-patches/2018-09/msg00024.html.

* data/c++.m4 (b4_cxx_portability): New.
(basic_symbol): In C++11, replace copy-ctors with move-ctors.
In C++11, replace copies with moves.
* data/lalr1.cc (stack_symbol_type, yypush_): Likewise.
Use YY_MOVE to avoid useless copies.
* data/variant.hh (variant): Support move-semantics.
(make_SYMBOL): In C++11, in order to support both read-only lvalues,
and rvalues, take the argument as a copy.
* data/stack.hh (yypush_): Use rvalue-refs in C++11.
* tests/c++.at: Use move semantics.

* tests/headers.at: Adjust to the new macros (YY_MOVE, etc.).

* configure.ac (CXX98_CXXFLAGS, CXX11_CXXFLAGS, CXX14_CXXFLAGS)
(CXX17_CXXFLAGS, ENABLE_CXX11): New.
* tests/atlocal.in: Receive them.

* examples/variant.yy: Don't define things in std.
* examples/variant-11.test, examples/variant-11.yy: New.
Check the support of move-only types.
* examples/README, examples/local.mk: Adjust.

examples/README

@@ -13,6 +13,10 @@ A C++ example that uses variants (they allow to use any C++ type as semantic
 value type) and symbol constructors (they ensure consistency between
 declared token type and effective semantic value).
 
+* variant-11.yy
+Another C++ example, closely related to the previous one, but exhibiting
+support for C++11's move semantics.
+
 -----
 
 Local Variables:
@@ -22,19 +26,11 @@ End:
 
 Copyright (C) 2018 Free Software Foundation, Inc.
 
-This file is part of Bison, the GNU Compiler Compiler.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
+Permission is granted to copy, distribute and/or modify this document
+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 no Front-Cover Texts, and with no Back-Cover
+Texts.  A copy of the license is included in the "GNU Free
+Documentation License" file as part of this distribution.
 
 # LocalWords:  mfcalc calc parsers yy

examples/local.mk

@@ -46,14 +46,24 @@ $(extracted): %D%/extracted.stamp
 ## Examples.  ##
 ## ---------- ##
 
+
 examplesdir = $(docdir)/examples
-dist_examples_DATA = %D%/README %D%/variant.yy
+dist_examples_DATA = %D%/README %D%/variant.yy %D%/variant-11.yy
 
 check_PROGRAMS += %D%/variant
 nodist_%C%_variant_SOURCES = %D%/variant.yy
 %C%_variant_CPPFLAGS = -I$(top_builddir)
 dist_TESTS += %D%/variant.test
+%D%/variant.cc: $(BISON_IN) $(dist_pkgdata_DATA)
 
+if ENABLE_CXX11
+  check_PROGRAMS += %D%/variant-11
+  nodist_%C%_variant_11_SOURCES = %D%/variant-11.yy
+  %C%_variant_11_CXXFLAGS = $(CXX11_CXXFLAGS)
+  %C%_variant_11_CPPFLAGS = -I$(top_builddir)
+  dist_TESTS += %D%/variant-11.test
+  %D%/variant-11.cc: $(BISON_IN) $(dist_pkgdata_DATA)
+endif
 
 include %D%/calc++/local.mk
 include %D%/mfcalc/local.mk

examples/variant-11.test

@@ -0,0 +1,19 @@
+#! /bin/sh
+
+# Copyright (C) 2018 Free Software Foundation, Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+: >input
+run 0 "{I have three numbers for you., 1, 2, 3, And that's all!}"

examples/variant-11.yy

@@ -0,0 +1,159 @@
+/*
+  Copyright (C) 2008-2015, 2018 Free Software Foundation, Inc.
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+%debug
+%language "c++"
+%defines
+%define api.token.constructor
+%define api.value.type variant
+%define parse.assert
+%locations
+
+%code requires // *.hh
+{
+#include <memory> // std::unique_ptr
+#include <string>
+#include <vector>
+
+  using string_uptr = std::unique_ptr<std::string>;
+  using string_uptrs = std::vector<string_uptr>;
+}
+
+%code // *.cc
+{
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <sstream>
+
+  namespace yy
+  {
+    // Prototype of the yylex function providing subsequent tokens.
+    static parser::symbol_type yylex ();
+
+    // Print a vector of strings.
+    std::ostream&
+    operator<< (std::ostream& o, const string_uptrs& ss)
+    {
+      o << '{';
+      const char *sep = "";
+      for (const auto& s: ss)
+        {
+          o << sep << *s;
+          sep = ", ";
+        }
+      return o << '}';
+    }
+  }
+
+  template <typename... Args>
+  string_uptr
+  make_string_uptr (Args&&... args)
+  {
+    // std::make_unique is C++14.
+    return std::unique_ptr<std::string>(new std::string{std::forward<Args>(args)...});
+  }
+
+  // Convert to string.
+  template <typename T>
+    std::string
+    to_string (const T& t)
+  {
+    auto&& o = std::ostringstream{};
+    o << t;
+    return o.str ();
+  }
+}
+
+%token <string_uptr> TEXT;
+%token <int> NUMBER;
+%printer { yyo << '(' << &$$ << ") " << $$; } <*>;
+%printer { yyo << *$$; } <string_uptr>;
+%token END_OF_FILE 0;
+
+%type <string_uptr> item;
+%type <string_uptrs> list;
+
+%%
+
+result:
+  list  { std::cout << $1 << '\n'; }
+;
+
+list:
+  %empty     { /* Generates an empty string list */ }
+| list item  { $$ = std::move ($1); $$.emplace_back (std::move ($2)); }
+;
+
+item:
+  TEXT    { $$ = std::move ($1); }
+| NUMBER  { $$ = make_string_uptr (to_string ($1)); }
+;
+%%
+
+namespace yy
+{
+  // The yylex function providing subsequent tokens:
+  // TEXT         "I have three numbers for you."
+  // NUMBER       1
+  // NUMBER       2
+  // NUMBER       3
+  // TEXT         "And that's all!"
+  // END_OF_FILE
+
+  static
+  parser::symbol_type
+  yylex ()
+  {
+    static auto count = 0u;
+    auto stage = count;
+    ++count;
+    auto loc = parser::location_type{nullptr, stage + 1, stage + 1};
+    switch (stage)
+      {
+      case 0:
+        return parser::make_TEXT (make_string_uptr ("I have three numbers for you."), std::move (loc));
+      case 1:
+      case 2:
+      case 3:
+        return parser::make_NUMBER (stage, std::move (loc));
+      case 4:
+        return parser::make_TEXT (make_string_uptr ("And that's all!"), std::move (loc));
+      default:
+        return parser::make_END_OF_FILE (std::move (loc));
+      }
+  }
+
+  // Mandatory error function
+  void
+  parser::error (const parser::location_type& loc, const std::string& msg)
+  {
+    std::cerr << loc << ": " << msg << '\n';
+  }
+}
+
+int
+main ()
+{
+  auto&& p = yy::parser{};
+  p.set_debug_level (!!getenv ("YYDEBUG"));
+  return p.parse ();
+}
+
+// Local Variables:
+// mode: C++
+// End:

examples/variant.yy

@@ -37,16 +37,12 @@ typedef std::vector<std::string> strings_type;
 #include <iterator>
 #include <sstream>
 
-  // Prototype of the yylex function providing subsequent tokens.
   namespace yy
   {
+    // Prototype of the yylex function providing subsequent tokens.
     static parser::symbol_type yylex ();
-  }
 
-  // Printing a vector of strings.
-  // Koening look up will look into std, since that's an std::vector.
-  namespace std
-  {
+    // Print a vector of strings.
     std::ostream&
     operator<< (std::ostream& o, const strings_type& ss)
     {
@@ -62,10 +58,10 @@ typedef std::vector<std::string> strings_type;
     }
   }
 
-  // Conversion to string.
+  // Convert to string.
   template <typename T>
     std::string
-    string_cast (const T& t)
+    to_string (const T& t)
   {
     std::ostringstream o;
     o << t;
@@ -94,7 +90,7 @@ list:
 
 item:
   TEXT    { std::swap ($$, $1); }
-| NUMBER  { $$ = string_cast ($1); }
+| NUMBER  { $$ = to_string ($1); }
 ;
 %%