Avoid c++ in unwind protect (#81)

Author: jimhester

inst/include/cpp11/doubles.hpp

@@ -80,21 +80,23 @@ inline r_vector<double>::r_vector(std::initializer_list<named_arg> il)
     : cpp11::r_vector<double>(safe[Rf_allocVector](REALSXP, il.size())),
       capacity_(il.size()) {
   protect_ = protect_sexp(data_);
+  int n_protected = 0;
 
   try {
     unwind_protect([&] {
       Rf_setAttrib(data_, R_NamesSymbol, Rf_allocVector(STRSXP, capacity_));
       SEXP names = PROTECT(Rf_getAttrib(data_, R_NamesSymbol));
+      ++n_protected;
       auto it = il.begin();
       for (R_xlen_t i = 0; i < capacity_; ++i, ++it) {
         data_p_[i] = REAL_ELT(it->value(), 0);
         SET_STRING_ELT(names, i, Rf_mkCharCE(it->name(), CE_UTF8));
       }
-      UNPROTECT(1);
+      UNPROTECT(n_protected);
     });
   } catch (const unwind_exception& e) {
     release_protect(protect_);
-    UNPROTECT(1);
+    UNPROTECT(n_protected);
     throw e;
   }
 }

inst/include/cpp11/environment.hpp

@@ -31,7 +31,7 @@ class environment {
 
     template <typename T>
     proxy& operator=(T value) {
-      unwind_protect([&] { Rf_defineVar(name_, as_sexp(value), parent_); });
+      safe[Rf_defineVar](name_, as_sexp(value), parent_);
       return *this;
     }
     operator SEXP() const { return safe[Rf_findVarInFrame3](parent_, name_, TRUE); };

inst/include/cpp11/integers.hpp

@@ -97,21 +97,23 @@ inline r_vector<int>::r_vector(std::initializer_list<named_arg> il)
     : cpp11::r_vector<int>(safe[Rf_allocVector](INTSXP, il.size())),
       capacity_(il.size()) {
   protect_ = protect_sexp(data_);
+  int n_protected = 0;
 
   try {
     unwind_protect([&] {
       Rf_setAttrib(data_, R_NamesSymbol, Rf_allocVector(STRSXP, capacity_));
       SEXP names = PROTECT(Rf_getAttrib(data_, R_NamesSymbol));
+      ++n_protected;
       auto it = il.begin();
       for (R_xlen_t i = 0; i < capacity_; ++i, ++it) {
         data_p_[i] = INTEGER_ELT(it->value(), 0);
         SET_STRING_ELT(names, i, Rf_mkCharCE(it->name(), CE_UTF8));
       }
-      UNPROTECT(1);
+      UNPROTECT(n_protected);
     });
   } catch (const unwind_exception& e) {
     release_protect(protect_);
-    UNPROTECT(1);
+    UNPROTECT(n_protected);
     throw e;
   }
 }

inst/include/cpp11/list.hpp

@@ -86,19 +86,24 @@ template <>
 inline r_vector<SEXP>::r_vector(std::initializer_list<named_arg> il)
     : cpp11::r_vector<SEXP>(safe[Rf_allocVector](VECSXP, il.size())),
       capacity_(il.size()) {
+  protect_ = protect_sexp(data_);
+  int n_protected = 0;
+
   try {
     unwind_protect([&] {
-      protect_ = protect_sexp(data_);
       Rf_setAttrib(data_, R_NamesSymbol, Rf_allocVector(STRSXP, capacity_));
-      sexp nms(names());
+      SEXP names = PROTECT(Rf_getAttrib(data_, R_NamesSymbol));
+      ++n_protected;
       auto it = il.begin();
       for (R_xlen_t i = 0; i < capacity_; ++i, ++it) {
         SET_VECTOR_ELT(data_, i, it->value());
-        SET_STRING_ELT(nms, i, Rf_mkCharCE(it->name(), CE_UTF8));
+        SET_STRING_ELT(names, i, Rf_mkCharCE(it->name(), CE_UTF8));
       }
+      UNPROTECT(n_protected);
     });
   } catch (const unwind_exception& e) {
     release_protect(protect_);
+    UNPROTECT(n_protected);
     throw e;
   }
 }

inst/include/cpp11/logicals.hpp

@@ -83,21 +83,23 @@ inline r_vector<Rboolean>::r_vector(std::initializer_list<named_arg> il)
     : cpp11::r_vector<Rboolean>(safe[Rf_allocVector](LGLSXP, il.size())),
       capacity_(il.size()) {
   protect_ = protect_sexp(data_);
+  int n_protected = 0;
 
   try {
     unwind_protect([&] {
       Rf_setAttrib(data_, R_NamesSymbol, Rf_allocVector(STRSXP, capacity_));
       SEXP names = PROTECT(Rf_getAttrib(data_, R_NamesSymbol));
+      ++n_protected;
       auto it = il.begin();
       for (R_xlen_t i = 0; i < capacity_; ++i, ++it) {
         data_p_[i] = static_cast<Rboolean>(LOGICAL_ELT(it->value(), 0));
         SET_STRING_ELT(names, i, Rf_mkCharCE(it->name(), CE_UTF8));
       }
-      UNPROTECT(1);
+      UNPROTECT(n_protected);
     });
   } catch (const unwind_exception& e) {
     release_protect(protect_);
-    UNPROTECT(1);
+    UNPROTECT(n_protected);
     throw e;
   }
 }

inst/include/cpp11/raws.hpp

@@ -90,21 +90,24 @@ inline r_vector<uint8_t>::r_vector(std::initializer_list<named_arg> il)
     : cpp11::r_vector<uint8_t>(safe[Rf_allocVector](RAWSXP, il.size())),
       capacity_(il.size()) {
   protect_ = protect_sexp(data_);
+  int n_protected = 0;
 
   try {
     unwind_protect([&] {
       Rf_setAttrib(data_, R_NamesSymbol, Rf_allocVector(STRSXP, capacity_));
       SEXP names = PROTECT(Rf_getAttrib(data_, R_NamesSymbol));
+      ++n_protected;
+
       auto it = il.begin();
       for (R_xlen_t i = 0; i < capacity_; ++i, ++it) {
         data_p_[i] = RAW_ELT(it->value(), 0);
         SET_STRING_ELT(names, i, Rf_mkCharCE(it->name(), CE_UTF8));
       }
-      UNPROTECT(1);
+      UNPROTECT(n_protected);
     });
   } catch (const unwind_exception& e) {
     release_protect(protect_);
-    UNPROTECT(1);
+    UNPROTECT(n_protected);
     throw e;
   }
 }

inst/include/cpp11/strings.hpp

@@ -125,21 +125,23 @@ inline r_vector<r_string>::r_vector(std::initializer_list<named_arg> il)
     : cpp11::r_vector<r_string>(safe[Rf_allocVector](STRSXP, il.size())),
       capacity_(il.size()) {
   protect_ = protect_sexp(data_);
+  int n_protected = 0;
 
   try {
     unwind_protect([&] {
       Rf_setAttrib(data_, R_NamesSymbol, Rf_allocVector(STRSXP, capacity_));
       SEXP names = PROTECT(Rf_getAttrib(data_, R_NamesSymbol));
+      ++n_protected;
       auto it = il.begin();
       for (R_xlen_t i = 0; i < capacity_; ++i, ++it) {
         SET_STRING_ELT(data_, i, STRING_ELT(it->value(), 0));
         SET_STRING_ELT(names, i, Rf_mkCharCE(it->name(), CE_UTF8));
       }
-      UNPROTECT(1);
+      UNPROTECT(n_protected);
     });
   } catch (const unwind_exception& e) {
     release_protect(protect_);
-    UNPROTECT(1);
+    UNPROTECT(n_protected);
     throw e;
   }
 }