Merge branch 'master' into bugfix/newdatetimevec_ctor

Author: eddelbuettel

ChangeLog

@@ -4,6 +4,21 @@
 
         * inst/include/Rcpp/date_datetime/newDatetimeVector.h (Rcpp): Small
         correction concerning timezone attribute to ctor from RTYPE
+2016-11-22  Jim Hester  <[email protected]>
+
+        * inst/src/api.cpp: Cleanup to stack message parseing
+        * inst/unitTests/cpp/exceptions.cpp: Unit tests for cleanup
+        * inst/unitTests/runit.exceptions.R: Ditto
+
+2016-11-19  James J Balamuta  <[email protected]>
+
+        * inst/unitTests/runit.environments.R: Added environment find unit tests
+        as well as a symbol access test for environment get.
+        * inst/unitTests/cpp/Environment.cpp: Idem
+
+2016-11-18  James J Balamuta  <[email protected]>
+        * vignettes/Rcpp-extending: Switched to attributes and
+          added external class pointer macro notes by MathurinD 
 
 2016-11-16  Dirk Eddelbuettel  <[email protected]>
 

inst/NEWS.Rd

@@ -3,6 +3,24 @@
 \newcommand{\ghpr}{\href{https://github.com/RcppCore/Rcpp/pull/#1}{##1}}
 \newcommand{\ghit}{\href{https://github.com/RcppCore/Rcpp/issues/#1}{##1}}
 
+\section{Changes in Rcpp version 0.12.9 (2017-01-xx)}{
+    \item Changes in Rcpp API:
+    \itemize{
+      \item The exception stack message is now correctly demangled on all
+      compiler versions (Jim Hester in \ghpr{598})
+    }
+    \item Changes in Rcpp unit tests
+    \itemize{
+      \item Added Environment::find unit tests and an Environment::get(Symbol)
+      test (James Balamuta in \ghpr{595} addressing issue \ghit{594}).
+    }	
+    \item Changes in Rcpp Documentation:
+    \itemize{
+      \item Exposed pointers macros were included in the Rcpp Extending vignette
+       (MathurinD; James Balamuta in \ghpr{592} addressing \ghit{418}).
+    }
+}
+
 \section{Changes in Rcpp version 0.12.8 (2016-11-16)}{
   \itemize{
     \item Changes in Rcpp API:

inst/unitTests/cpp/Environment.cpp

@@ -37,6 +37,21 @@ SEXP runit_get( Environment env, std::string name){
     return env.get( name ) ;
 }
 
+// [[Rcpp::export]]
+SEXP runit_get_symbol( Environment env, Symbol name){
+    return env.get( name ) ;
+}
+
+// [[Rcpp::export]]
+SEXP runit_find( Environment env, std::string name){
+    return env.find( name ) ;
+}
+
+// [[Rcpp::export]]
+SEXP runit_find_symbol( Environment env, Symbol name){
+    return env.find( name ) ;
+}
+
 // [[Rcpp::export]]
 bool runit_exists( Environment env, std::string st){
     return env.exists( st ) ;

inst/unitTests/cpp/exceptions.cpp

@@ -38,6 +38,14 @@ double takeLogRcpp(double val) {
     return log(val);
 }
 
+// [[Rcpp::export]]
+double takeLogStop(double val) {
+    if (val <= 0.0) {
+        Rcpp::stop("Inadmissible value");
+    }
+    return log(val);
+}
+
 // [[Rcpp::export]]
 double takeLogRcppLocation(double val) {
     if (val <= 0.0) {

inst/unitTests/runit.environments.R

@@ -43,14 +43,44 @@ if (.runThisTest) {
         e <- new.env( )
         e$a <- 1:10
         e$b <- "foo"
-
-        checkEquals( runit_get( e, "a" ), e$a, msg = "Environment::get()" )
-        checkEquals( runit_get( e, "foobar" ), NULL, msg = "Environment::get()" )
+        
+        # Access with string
+        checkEquals( runit_get( e, "a" ), e$a, msg = "Environment::get(string)" )
+        checkEquals( runit_get( e, "foobar" ), NULL, msg = "Environment::get(string)" )
         checkEquals( runit_get( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags,
-                    msg = "Environment(namespace)::get() " )
-
-    }
-
+                     msg = "Environment(namespace)::get(string) " )
+        
+        # Access with Symbol constructed on call from string
+        checkEquals( runit_get_symbol( e, "a" ), e$a, msg = "Environment::get(Symbol)" )
+        checkEquals( runit_get_symbol( e, "foobar" ), NULL, msg = "Environment::get(Symbol)" )
+        checkEquals( runit_get_symbol( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags,
+                     msg = "Environment(namespace)::get(Symbol) " )
+        
+    }    
+
+    test.environment.find <- function(){
+        e <- new.env( )
+        e$a <- 1:10
+        e$b <- "foo"
+        bar <- "me"
+        
+        # Access with string
+        checkEquals( runit_find( e, "a" ), e$a, msg = "Environment::find(string)" )
+        checkException( runit_find( e, "foobar" ), NULL, msg = "Environment::find(string) not found" )
+        checkEquals( runit_find( e, "bar"), bar, msg = "Environment::find(string) inheritance" )
+        checkEquals( runit_find( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags,
+                     msg = "Environment(namespace)::find(string)" )
+        
+        # Access with Symbol constructed on call from string
+        checkEquals( runit_find_symbol( e, "a" ), e$a, msg = "Environment::find(Symbol)" )
+        checkException( runit_find_symbol( e, "foobar" ), NULL, msg = "Environment::find(Symbol) not found" )
+        checkEquals( runit_find_symbol( e, "bar"), bar, msg = "Environment::find(Symbol) inheritance" )
+        checkEquals( runit_find_symbol( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags,
+                     msg = "Environment(namespace)::find(Symbol)" )
+        
+    }    
+    
+        
     test.environment.exists <- function(){
         e <- new.env( )
         e$a <- 1:10

inst/unitTests/runit.exceptions.R

@@ -58,6 +58,24 @@ test.rcppException <- function() {
   checkEquals(condition$call, quote(takeLogRcpp(-1L)))
 }
 
+test.rcppStop <- function() {
+
+  # Code works normally without an exception
+  checkIdentical(takeLog(1L), log(1L))
+
+  # C++ exceptions are converted to R conditions
+  condition <- tryCatch(takeLogStop(-1L), error = identity)
+
+  checkIdentical(condition$message, "Inadmissible value")
+  checkIdentical(class(condition), c("Rcpp::exception", "C++Error", "error", "condition"))
+
+  checkTrue(!is.null(condition$cppstack))
+
+  checkIdentical(class(condition$cppstack), "Rcpp_stack_trace")
+
+  checkEquals(condition$call, quote(takeLogStop(-1L)))
+}
+
 test.rcppExceptionLocation <- function() {
 
   # Code works normally without an exception

src/api.cpp

@@ -38,15 +38,24 @@ using namespace Rcpp;
     #else
         #include <execinfo.h>
 
+        // Extract mangled name e.g. ./test(baz+0x14)[0x400962]
         static std::string demangler_one(const char* input) {
             static std::string buffer;
             buffer = input;
-            buffer.resize(buffer.find_last_of('+') - 1);
-            buffer.erase(
-                buffer.begin(),
-                buffer.begin() + buffer.find_last_of(' ') + 1
-            );
-            return demangle(buffer);
+            size_t last_open = buffer.find_last_of('(');
+            size_t last_close = buffer.find_last_of(')');
+            if (last_open == std::string::npos ||
+                last_close == std::string::npos) {
+              return input;
+            }
+            std::string function_name = buffer.substr(last_open + 1, last_close - last_open - 1);
+            // Strip the +0x14 (if it exists, which it does not in earlier versions of gcc)
+            size_t function_plus = function_name.find_last_of('+');
+            if (function_plus != std::string::npos) {
+              function_name.resize(function_plus);
+            }
+            buffer.replace(last_open + 1, function_name.size(), demangle(function_name));
+            return buffer;
         }
     #endif
 #endif

vignettes/Rcpp-extending.Rnw

@@ -91,8 +91,11 @@ These converters are often used implicitly, as in the following code chunk:
 
 <<echo=FALSE>>=
 code <- '
-// we get a list from R
-List input(input_) ;
+#include <Rcpp.h>
+using namespace Rcpp;
+
+// [[Rcpp::export]]
+List fx(List input){ // we get a list from R
 
 // pull std::vector<double> from R list
 // this is achieved through an implicit call to Rcpp::as
@@ -103,7 +106,8 @@ std::vector<double> x = input["x"] ;
 return List::create(
     _["front"] = x.front(),
     _["back"]  = x.back()
-    ) ;
+    );
+}
 '
 writeLines( code, "code.cpp" )
 @
@@ -112,10 +116,7 @@ external_highlight( "code.cpp", type = "LATEX", doc = FALSE )
 @
 
 <<>>=
-fx <- cxxfunction( signature( input_ = "list"),
-	paste( readLines( "code.cpp" ), collapse = "\n" ),
-	plugin = "Rcpp"
-	)
+Rcpp::sourceCpp(file= "code.cpp")
 input <- list( x = seq(1, 10, by = 0.5) )
 fx( input )
 @
@@ -186,6 +187,18 @@ It should be noted that only the declaration is required. The implementation
 can appear after the \texttt{Rcpp.h} file is included, and therefore take
 full advantage of the \pkg{Rcpp} type system.
 
+Another non-intrusive option is to expose an external pointer. The macro 
+\texttt{RCPP\_EXPORT\_WRAP} provides an easy way to expose a \proglang{C++} class 
+to \proglang{R} as an external pointer. It can be used instead of specializing
+\texttt{Rcpp::wrap}, and should not be used simultaneously. 
+
+<<lang=cpp>>=
+#include RcppCommon.h
+#include foobar.h
+
+RCPP_EXPORT_WRAP(Bar);
+@
+
 \subsection{Templates and partial specialization}
 
 It is perfectly valid to declare a partial specialization for the
@@ -227,8 +240,6 @@ will attempt to use the constructor of the target class taking a \texttt{SEXP}.
 <<lang=cpp>>=
 #include <RcppCommon.h>
 
-#include <RcppCommon.h>
-
 class Foo{
     public:
         Foo() ;
@@ -237,18 +248,16 @@ class Foo{
         Foo(SEXP) ;
 }
 
-#include <Rcpp.h>
-
 
 // this must appear after the specialization,
 // otherwise the specialization will not be seen by Rcpp types
 #include <Rcpp.h>
 @
 
-\subsection{Non intrusive extension}
+\subsection{Non-intrusive extension}
 
 It is also possible to fully specialize \texttt{Rcpp::as} to enable
-non intrusive implicit conversion capabilities.
+non-intrusive implicit conversion capabilities.
 
 <<lang=cpp>>=
 #include <RcppCommon.h>
@@ -266,6 +275,28 @@ namespace Rcpp {
 #include <Rcpp.h>
 @
 
+Furthermore, another non-intrusive option is to opt for sharing an R 
+external pointer. The macro \texttt{RCPP\_EXPORT\_AS} provides an easy way to
+extend \texttt{Rcpp::as} to expose \proglang{R} external pointers to 
+\proglang{C++}. It can be used instead of specializing \texttt{Rcpp::as}, and 
+should not be used simultaneously.
+
+<<lang=cpp>>=
+#include RcppCommon.h
+#include foobar.h
+
+RCPP_EXPORT_AS(Bar);
+@
+
+With this being said, there is one additional macro that can be used to 
+simultaneously define both \texttt{Rcpp::wrap} and \texttt{Rcpp::as}
+specialization for an external pointer. The macro \texttt{RCPP\_EXPOSED\_CLASS} 
+can be use to transparently exchange a class between \proglang{R} and 
+\proglang{C++} as an external pointer. Do not simultaneously use it alongside
+\texttt{RCPP\_EXPOSED\_AS}, \texttt{RCPP\_EXPOSED\_WRAP}, \texttt{Rcpp::wrap}, or
+\texttt{Rcpp::as}.
+
+
 \subsection{Templates and partial specialization}
 
 The signature of \texttt{Rcpp::as} does not allow partial specialization.