Merge pull request #1139 from Enchufa2/fix/Rostreams

Address #928: enable global Rcout/Rcerr via RCPP_USE_GLOBAL_ROSTREAM

Author: eddelbuettel

ChangeLog

@@ -1,3 +1,13 @@
+2021-01-28  Iñaki Ucar  <iucar@fedoraproject.org>
+
+	* inst/include/Rcpp/iostream/Rstreambuf.h: Support for global Rcout/Rcerr by
+	adding `-DRCPP_USE_GLOBAL_ROSTREAM` to `PKG_CPPFLAGS`. This behavior mimics
+	std::cout/cerr. Required initialization code is automatically generated.
+	* inst/include/Rcpp/routines.h: Ditto
+	* src/api.cpp: Ditto
+	* src/attributes.cpp: Ditto
+	* src/rcpp_init.cpp: Ditto
+
 2021-01-21  Dirk Eddelbuettel  <edd@debian.org>
 
         * DESCRIPTION (Version, Date): Roll minor version

inst/include/Rcpp/iostream/Rstreambuf.h

@@ -2,7 +2,8 @@
 //
 // Rstreambuf.h: Rcpp R/C++ interface class library -- stream buffer
 //
-// Copyright (C) 2011 - 2017  Dirk Eddelbuettel, Romain Francois and Jelmer Ypma
+// Copyright (C) 2011 - 2020  Dirk Eddelbuettel, Romain Francois and Jelmer Ypma
+// Copyright (C) 2021         Dirk Eddelbuettel, Romain Francois, Jelmer Ypma and Iñaki Ucar
 //
 // This file is part of Rcpp.
 //
@@ -80,9 +81,14 @@ namespace Rcpp {
         ::R_FlushConsole();
         return 0;
     }								// #nocov end
-    static Rostream<true>  Rcout;
-    static Rostream<false> Rcerr;
 
+#ifdef RCPP_USE_GLOBAL_ROSTREAM
+    extern Rostream<true>&  Rcout;
+    extern Rostream<false>& Rcerr;
+#else
+    static Rostream<true>   Rcout;
+    static Rostream<false>  Rcerr;
+#endif
 
 }
 

inst/include/Rcpp/routines.h

@@ -23,6 +23,8 @@
 #ifndef RCPP_ROUTINE_H
 #define RCPP_ROUTINE_H
 
+#include <Rcpp/iostream/Rstreambuf.h>
+
 #if defined(COMPILING_RCPP)
 
 // the idea is that this file should be generated automatically by Rcpp::register
@@ -45,6 +47,9 @@ namespace Rcpp{
     void Rcpp_precious_teardown();
     SEXP Rcpp_precious_preserve(SEXP object);
     void Rcpp_precious_remove(SEXP token);
+
+    Rostream<true>&  Rcpp_cout_get();
+    Rostream<false>& Rcpp_cerr_get();
 }
 
 SEXP          rcpp_get_stack_trace();
@@ -155,6 +160,17 @@ namespace Rcpp {
         fun(token);
     }
 
+    inline attribute_hidden Rostream<true>&  Rcpp_cout_get() {
+        typedef Rostream<true>& (*Fun)();
+        static Fun fun = GET_CALLABLE("Rcpp_cout_get");
+        return fun();
+    }
+    inline attribute_hidden Rostream<false>& Rcpp_cerr_get() {
+        typedef Rostream<false>& (*Fun)();
+        static Fun fun = GET_CALLABLE("Rcpp_cerr_get");
+        return fun();
+    }
+
 }
 
 // The 'attribute_hidden' used here is a simple precessor defined from

inst/tinytest/test_global_rostream.R

@@ -0,0 +1,108 @@
+
+##  Copyright (C) 2021  Iñaki Ucar
+##
+##  This file is part of Rcpp.
+##
+##  Rcpp 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 2 of the License, or
+##  (at your option) any later version.
+##
+##  Rcpp 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 Rcpp.  If not, see <http://www.gnu.org/licenses/>.
+
+.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" && Sys.getenv("RunVerboseRcppTests") == "yes"
+
+if (! .runThisTest) exit_file("Set 'RunVerboseRcppTests' and 'RunAllRcppTests' to 'yes' to run.")
+
+library(Rcpp)
+
+mkv <- "PKG_CPPFLAGS = -DRCPP_USE_GLOBAL_ROSTREAM"
+cfg <- "
+#ifndef RCPP_USE_GLOBAL_ROSTREAM
+#define RCPP_USE_GLOBAL_ROSTREAM
+#endif
+#include <Rcpp.h>
+using namespace Rcpp;"
+ptr <- "
+// [[Rcpp::export]]
+CharacterVector ptr%s() {
+    CharacterVector out(2);
+    std::ostringstream Rcout_address, Rcerr_address;
+    Rcout_address << (void const *)(&Rcout);
+    Rcerr_address << (void const *)(&Rcerr);
+    out[0] = Rcout_address.str();
+    out[1] = Rcerr_address.str();
+    return out;
+}"
+alig <- "
+// [[Rcpp::export]]
+void toLeft() {
+    Rcout << std::left;
+    Rcerr << std::left;
+}
+// [[Rcpp::export]]
+void toRight() {
+    Rcout << std::right;
+    Rcerr << std::right;
+}"
+print <- '
+// [[Rcpp::export]]
+void something() {
+    Rcout << std::setw(20) << "somethingRcout" << std::endl;
+    Rcerr << std::setw(20) << "somethingRcerr" << std::endl;
+}'
+
+# create package and write functions into separate translation units
+pkg_name <- "fooRostream"
+path <- tempdir()
+pkg_path <- file.path(path, pkg_name)
+src_path <- file.path(pkg_path, "src")
+
+if (dir.exists(pkg_path)) unlink(pkg_path)
+Rcpp.package.skeleton(
+    pkg_name, path=path, environment=environment(), example_code=FALSE)
+writeLines(c(cfg, sprintf(ptr, "A")), file.path(src_path, "ptrA.cpp"))
+writeLines(c(cfg, sprintf(ptr, "B")), file.path(src_path, "ptrB.cpp"))
+writeLines(c(cfg, alig), file.path(src_path, "alig.cpp"))
+writeLines(c(cfg, print), file.path(src_path, "print.cpp"))
+writeLines(mkv, file.path(src_path, "Makevars"))
+compileAttributes(pkg_path)
+
+# tests
+testRostream <- function() {
+    captureFun <- function(...) {
+        err <- capture.output(
+            out <- capture.output(..., type="output"), type="message")
+        c(out, err)
+    }
+    res <- all(ptrA() == ptrB())
+    res <- c(res, all(grepl("^ ", captureFun(something()))))
+    toLeft() # change alignment globally
+    res <- c(res, all(grepl("^s", captureFun(something()))))
+    toRight() # restore
+    res
+}
+
+# test package
+lib_path <- file.path(path, "templib")
+dir.create(lib_path)
+install.packages(pkg_path, lib_path, repos=NULL, type="source")
+expect_true(require("fooRostream", lib.loc=lib_path, character.only=TRUE))
+expect_true(all(testRostream()))
+
+# test sourceCpp
+sourceCpp(file.path(src_path, "ptrA.cpp"))
+sourceCpp(file.path(src_path, "ptrB.cpp"))
+sourceCpp(file.path(src_path, "alig.cpp"))
+sourceCpp(file.path(src_path, "print.cpp"))
+expect_true(all(testRostream()))
+
+# cleanup
+on.exit(unlink(pkg_path, recursive=TRUE), add=TRUE)
+on.exit(unlink(lib_path, recursive=TRUE), add=TRUE)

src/api.cpp

@@ -3,6 +3,7 @@
 // api.cpp: Rcpp R/C++ interface class library -- Rcpp api
 //
 // Copyright (C) 2012 - 2020  Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2021         Dirk Eddelbuettel, Romain Francois and Iñaki Ucar
 //
 // This file is part of Rcpp.
 //
@@ -20,6 +21,7 @@
 // along with Rcpp.  If not, see <http://www.gnu.org/licenses/>.
 
 #define COMPILING_RCPP
+#define RCPP_USE_GLOBAL_ROSTREAM
 
 #include <Rcpp.h>
 
@@ -33,6 +35,18 @@ using namespace Rcpp;
 #endif
 
 namespace Rcpp {
+    // [[Rcpp::register]]
+    Rostream<true>&  Rcpp_cout_get() {
+      static Rostream<true>  Rcpp_cout;
+      return Rcpp_cout;
+    }
+    // [[Rcpp::register]]
+    Rostream<false>& Rcpp_cerr_get() {
+      static Rostream<false> Rcpp_cerr;
+      return Rcpp_cerr;
+    }
+    Rostream<true>&  Rcout = Rcpp_cout_get();
+    Rostream<false>& Rcerr = Rcpp_cerr_get();
 
     namespace internal {
 

src/attributes.cpp

@@ -1,7 +1,8 @@
 //
 // attributes.cpp: Rcpp R/C++ interface class library -- Rcpp attributes
 //
-// Copyright (C) 2012 - 2021  JJ Allaire, Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2012 - 2020  JJ Allaire, Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2021         JJ Allaire, Dirk Eddelbuettel, Romain Francois and Iñaki Ucar
 //
 // This file is part of Rcpp.
 //
@@ -795,6 +796,8 @@ namespace attributes {
 
     std::string generateRArgList(const Function& function);
 
+    void initializeGlobals(std::ostream& ostr);
+
     void generateCpp(std::ostream& ostr,
                      const SourceFileAttributes& attributes,
                      bool includePrototype,
@@ -2127,6 +2130,8 @@ namespace attributes {
 
         // always bring in Rcpp
         ostr << "using namespace Rcpp;" << std::endl << std::endl;
+        // initialize references to global Rostreams
+        initializeGlobals(ostr);
 
         // commit with preamble
         return ExportsGenerator::commit(ostr.str());
@@ -2742,6 +2747,16 @@ namespace attributes {
         return argsOstr.str();
     }
 
+    // Generate the C++ code required to initialize global objects
+    void initializeGlobals(std::ostream& ostr) {
+        ostr << "#ifdef RCPP_USE_GLOBAL_ROSTREAM" << std::endl;
+        ostr << "Rcpp::Rostream<true>&  Rcpp::Rcout = Rcpp::Rcpp_cout_get();";
+        ostr << std::endl;
+        ostr << "Rcpp::Rostream<false>& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get();";
+        ostr << std::endl;
+        ostr << "#endif" << std::endl << std::endl;
+    }
+
     // Generate the C++ code required to make [[Rcpp::export]] functions
     // available as C symbols with SEXP parameters and return
     void generateCpp(std::ostream& ostr,
@@ -3188,6 +3203,8 @@ namespace {
             // always include Rcpp.h in case the user didn't
             ostr << std::endl << std::endl;
             ostr << "#include <Rcpp.h>" << std::endl;
+            // initialize references to global Rostreams
+            initializeGlobals(ostr);
             generateCpp(ostr, sourceAttributes, true, false, contextId_);
             generatedCpp_ = ostr.str();
             std::ofstream cppOfs(generatedCppSourcePath().c_str(),

src/rcpp_init.cpp

@@ -2,6 +2,7 @@
 // Rcpp_init.cpp : Rcpp R/C++ interface class library -- Initialize and register
 //
 // Copyright (C) 2010 - 2020  John Chambers, Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2021         John Chambers, Dirk Eddelbuettel, Romain Francois and Iñaki Ucar
 //
 // This file is part of Rcpp.
 //
@@ -124,6 +125,8 @@ void registerFunctions(){
     RCPP_REGISTER(Rcpp_precious_teardown)
     RCPP_REGISTER(Rcpp_precious_preserve)
     RCPP_REGISTER(Rcpp_precious_remove)
+    RCPP_REGISTER(Rcpp_cout_get)
+    RCPP_REGISTER(Rcpp_cerr_get)
     #undef RCPP_REGISTER
 }