Handle longjumps in cpp interfaces

Author: lionel-

ChangeLog

@@ -33,6 +33,16 @@
         * inst/include/Rcpp/macros/macros.h: Leave the try/catch scope before
         resuming jump to ensure proper destruction of the exception reference.
 
+        * inst/include/Rcpp/exceptions.h: Functions to create and check a
+        longjump sentinel. This sentinel is used as return value in contexts
+        where it is not safe to resume a jump (i.e. in the glue code of cpp
+        interfaces).
+
+        * inst/include/Rcpp/macros/macros.h: Return a longjump sentinel in
+        END_RCPP_RETURN_ERROR.
+
+        * src/attributes.cpp: Detect longjump sentinels and resume jump.
+
 2018-05-09  Dirk Eddelbuettel  <[email protected]>
 
         * DESCRIPTION: Release 0.12.17

inst/include/Rcpp/exceptions.h

@@ -113,12 +113,41 @@ namespace Rcpp {
 
     namespace internal {
 
+        inline SEXP longjumpSentinel(SEXP token) {
+            SEXP sentinel = PROTECT(Rf_allocVector(VECSXP, 1));
+            SET_VECTOR_ELT(sentinel, 0, token);
+
+            SEXP sentinelClass = PROTECT(Rf_mkString("Rcpp:longjumpSentinel"));
+            Rf_setAttrib(sentinel, R_ClassSymbol, sentinelClass) ;
+
+            UNPROTECT(2);
+            return sentinel;
+        }
+
+        inline bool isLongjumpSentinel(SEXP x) {
+            return
+                Rf_inherits(x, "Rcpp:longjumpSentinel") &&
+                TYPEOF(x) == VECSXP &&
+                Rf_length(x) == 1;
+        }
+
+        inline SEXP getLongjumpToken(SEXP sentinel) {
+            return VECTOR_ELT(sentinel, 0);
+        }
+
         struct LongjumpException {
             SEXP token;
-            LongjumpException(SEXP token_) : token(token_) { }
+            LongjumpException(SEXP token_) : token(token_) {
+                if (isLongjumpSentinel(token)) {
+                    token = getLongjumpToken(token);
+                }
+            }
         };
 
         inline void resumeJump(SEXP token) {
+            if (isLongjumpSentinel(token)) {
+                token = getLongjumpToken(token);
+            }
             ::R_ReleaseObject(token);
 #if (defined(RCPP_PROTECTED_EVAL) && defined(R_VERSION) && R_VERSION >= R_Version(3, 5, 0))
             ::R_ContinueUnwind(token);

inst/include/Rcpp/macros/macros.h

@@ -85,19 +85,14 @@
     return Rcpp::internal::interruptedError();                                 \
   }                                                                            \
   catch (Rcpp::internal::LongjumpException& __ex__) {                          \
-    rcpp_output_type = 3 ;                                                     \
-    rcpp_output_condition = __ex__.token;                                      \
+    return Rcpp::internal::longjumpSentinel(__ex__.token);                     \
   }                                                                            \
   catch (std::exception &__ex__) {                                             \
     return exception_to_try_error(__ex__);                                     \
   }                                                                            \
   catch (...) {                                                                \
     return string_to_try_error("c++ exception (unknown reason)");              \
   }                                                                            \
-  if (rcpp_output_type == 3) {                                                 \
-    Rcpp::internal::resumeJump(rcpp_output_condition);                         \
-    Rf_error("Internal error: Rcpp longjump failed to resume");                \
-  }                                                                            \
   return R_NilValue;
 #endif
 

src/attributes.cpp

@@ -2190,6 +2190,10 @@ namespace attributes {
                        << std::endl
                        << "            throw Rcpp::internal::InterruptedException();"
                        << std::endl;
+                ostr() << "        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))"
+                       << std::endl
+                       << "            throw Rcpp::internal::LongjumpException(rcpp_result_gen);"
+                       << std::endl;
                 ostr() << "        if (rcpp_result_gen.inherits(\"try-error\"))"
                        << std::endl
                        << "            throw Rcpp::exception(Rcpp::as<std::string>("
@@ -2774,6 +2778,12 @@ namespace attributes {
                      << "        UNPROTECT(1);" << std::endl
                      << "        Rf_onintr();" << std::endl
                      << "    }" << std::endl
+                     << "    bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen);" << std::endl
+                     << "    if (rcpp_isLongjump_gen) {" << std::endl
+                                 // No need to unprotect before jump
+                     << "        Rcpp::internal::resumeJump(rcpp_result_gen);" << std::endl
+                     << "        Rf_error(\"Internal error: Rcpp longjump failed to resume\");" << std::endl
+                     << "    }" << std::endl
                      << "    Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, \"try-error\");"
                      << std::endl
                      << "    if (rcpp_isError_gen) {" << std::endl