not using fmt

Author: pachadotdev

extended-tests/cpp4rtest/src/errors_fmt.h

@@ -1,17 +1,12 @@
-#define CPP4R_USE_FMT
-#define FMT_HEADER_ONLY
-#include "fmt/core.h"
-#include "fmt/format.h"
-
 [[cpp4r::register]] void my_stop(std::string mystring, int myarg) {
-  cpp4r::stop(fmt::format(fmt::runtime(mystring), myarg));
+  cpp4r::stop(mystring);
 }
 [[cpp4r::register]] void my_stop_n1(std::string mystring) { cpp4r::stop(mystring); }
 [[cpp4r::register]] void my_warning(std::string mystring, std::string myarg) {
-  cpp4r::warning(fmt::format(fmt::runtime(mystring), myarg));
+  cpp4r::warning(mystring);
 }
 [[cpp4r::register]] void my_warning_n1(std::string mystring) { cpp4r::warning(mystring); }
 [[cpp4r::register]] void my_message(std::string mystring, std::string myarg) {
-  cpp4r::message(fmt::format(fmt::runtime(mystring), myarg));
+  cpp4r::message(mystring);
 }
 [[cpp4r::register]] void my_message_n1(std::string mystring) { cpp4r::message(mystring); }

extended-tests/cpp4rtest/src/test-protect.h

@@ -1,5 +1,3 @@
-#define CPP4R_USE_FMT
-
 #include <testthat.h>
 
 context("unwind_protect-C++") {
@@ -39,9 +37,7 @@ context("unwind_protect-C++") {
 
   test_that("stop throws an unwind_exception") {
     expect_error_as(cpp4r::stop("error"), cpp4r::unwind_exception);
-    expect_error_as(cpp4r::stop("error {}", "message"), cpp4r::unwind_exception);
-    expect_error_as(cpp4r::stop("error {a}", fmt::arg("a", "message")),
-                    cpp4r::unwind_exception);
+    expect_error_as(cpp4r::stop("error %s", "message"), cpp4r::unwind_exception);
   }
 
   test_that("safe wraps R functions and works if there is an R error") {

extended-tests/cpp4rtest/tests/testthat/test_formatted_errors.R

@@ -1,27 +1,11 @@
-test_that("cpp4r::stop formatting works", {
-  test1 <- 4
+test_that("cpp4r::stop basic behavior", {
   expect_error(my_stop_n1("This is a stop"), "This is a stop", fixed = TRUE)
-  expect_error(my_stop("Your number is {}", test1), "Your number is 4", fixed = TRUE)
-
-  test2 <- c(3, 5, 7)
-  expect_error(my_stop("You've tested this {} times", test2[1]), "You've tested this 3 times",
-               fixed = TRUE)
 })
-test_that("cpp4r::warning formatting works", {
-  test1 <- "warning"
+test_that("cpp4r::warning basic behavior", {
   expect_warning(my_warning_n1("This is a warning"), "This is a warning", fixed = TRUE)
-  expect_warning(my_warning("This is a {}", test1), "This is a warning", fixed = TRUE)
-
-  test2 <- c("failed", "passed")
-  expect_warning(my_warning("You {}", test2[2]), "You passed", fixed = TRUE)
 })
-test_that("cpp4r::message formatting works", {
-  test1 <- "message"
+test_that("cpp4r::message basic behavior", {
   expect_message(my_message_n1("This is a message"), "This is a message", fixed = TRUE)
-  expect_message(my_message("This is a {}", test1), "This is a message", fixed = TRUE)
-
-  test2 <- c("great", "super")
-  expect_message(my_message("You're {}", test2[2]), "You're super", fixed = TRUE)
 })
 test_that("cpp4r::stop works without including the fmt library", {
   test1 <- "error"

inst/include/cpp4r/function.hpp

@@ -106,32 +106,20 @@ inline void r_message(const char* x) {
 }  // namespace detail
 
 inline void message(const char* fmt_arg) {
-#ifdef CPP4R_USE_FMT
-  std::string msg = fmt::format(fmt_arg);
-  safe[detail::r_message](msg.c_str());
-#else
   char buff[1024];
-  int msg;
-  msg = std::snprintf(buff, 1024, "%s", fmt_arg);
+  int msg = std::snprintf(buff, 1024, "%s", fmt_arg);
   if (msg >= 0 && msg < 1024) {
     safe[detail::r_message](buff);
   }
-#endif
 }
 
 template <typename... Args>
 void message(const char* fmt_arg, Args... args) {
-#ifdef CPP4R_USE_FMT
-  std::string msg = fmt::format(fmt_arg, args...);
-  safe[detail::r_message](msg.c_str());
-#else
   char buff[1024];
-  int msg;
-  msg = std::snprintf(buff, 1024, fmt_arg, args...);
+  int msg = std::snprintf(buff, 1024, fmt_arg, args...);
   if (msg >= 0 && msg < 1024) {
     safe[detail::r_message](buff);
   }
-#endif
 }
 
 inline void message(const std::string& fmt_arg) { message(fmt_arg.c_str()); }

inst/include/cpp4r/protect.hpp

@@ -14,11 +14,6 @@
 #include "R_ext/Print.h"    // for REprintf
 #include "R_ext/Utils.h"    // for R_CheckUserInterrupt
 
-#ifdef CPP4R_USE_FMT
-#define FMT_HEADER_ONLY
-#include "fmt/core.h"
-#endif
-
 namespace cpp4r {
 class unwind_exception : public std::exception {
  public:
@@ -183,31 +178,6 @@ constexpr struct protect safe = {};
 
 inline void check_user_interrupt() { safe[R_CheckUserInterrupt](); }
 
-#ifdef CPP4R_USE_FMT
-template <typename... Args>
-void stop [[noreturn]] (const char* fmt_arg, Args&&... args) {
-  std::string msg = fmt::format(fmt_arg, std::forward<Args>(args)...);
-  safe.noreturn(Rf_errorcall)(R_NilValue, "%s", msg.c_str());
-}
-
-template <typename... Args>
-void stop [[noreturn]] (const std::string& fmt_arg, Args&&... args) {
-  std::string msg = fmt::format(fmt_arg, std::forward<Args>(args)...);
-  safe.noreturn(Rf_errorcall)(R_NilValue, "%s", msg.c_str());
-}
-
-template <typename... Args>
-void warning(const char* fmt_arg, Args&&... args) {
-  std::string msg = fmt::format(fmt_arg, std::forward<Args>(args)...);
-  safe[Rf_warningcall](R_NilValue, "%s", msg.c_str());
-}
-
-template <typename... Args>
-void warning(const std::string& fmt_arg, Args&&... args) {
-  std::string msg = fmt::format(fmt_arg, std::forward<Args>(args)...);
-  safe[Rf_warningcall](R_NilValue, "%s", msg.c_str());
-}
-#else
 template <typename... Args>
 void stop [[noreturn]] (const char* fmt, Args... args) {
   safe.noreturn(Rf_errorcall)(R_NilValue, fmt, args...);
@@ -227,7 +197,6 @@ template <typename... Args>
 void warning(const std::string& fmt, Args... args) {
   safe[Rf_warningcall](R_NilValue, fmt.c_str(), args...);
 }
-#endif
 
 namespace detail {
 

inst/include/cpp4r/r_bool.hpp

@@ -42,10 +42,11 @@ class r_bool {
  private:
   static constexpr int na = std::numeric_limits<int>::min();
 
+  // C++11 constexpr must be single return statement
   static constexpr int from_int(int value) noexcept {
-    if (value == static_cast<int>(FALSE)) return FALSE;
-    if (value == static_cast<int>(na)) return na;
-    return TRUE;
+    return (value == static_cast<int>(FALSE)) ? FALSE :
+           (value == static_cast<int>(na)) ? na :
+           TRUE;
   }
 
   int value_ = na;

inst/include/cpp4r/r_vector_writable_impl.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "cpp4r/r_vector_fwd.hpp"
+#include "cpp4r/cpp_version.hpp"  // for CPP4R feature detection
 
 namespace cpp4r {
 namespace writable {
@@ -119,6 +120,8 @@ inline r_vector<T>::r_vector(std::initializer_list<named_arg> il)
       // SAFETY: We've validated type and length ahead of this.
       const underlying_type elt = get_elt(value, 0);
 
+#if CPP4R_HAS_CXX17
+      // C++17+: Use if constexpr for compile-time dispatch
       if constexpr (std::is_same<T, cpp4r::r_string>::value) {
         // Translate to UTF-8 before assigning for string types
         SEXP translated_elt = Rf_mkCharCE(Rf_translateCharUTF8(elt), CE_UTF8);
@@ -137,6 +140,25 @@ inline r_vector<T>::r_vector(std::initializer_list<named_arg> il)
           set_elt(data_, i, elt);
         }
       }
+#else
+      // C++11/14: Runtime check instead of if constexpr
+      if (std::is_same<T, cpp4r::r_string>::value) {
+        // Translate to UTF-8 before assigning for string types
+        SEXP translated_elt = Rf_mkCharCE(Rf_translateCharUTF8(elt), CE_UTF8);
+
+        if (data_p_ != nullptr) {
+          data_p_[i] = translated_elt;
+        } else {
+          set_elt(data_, i, translated_elt);
+        }
+      } else {
+        if (data_p_ != nullptr) {
+          data_p_[i] = elt;
+        } else {
+          set_elt(data_, i, elt);
+        }
+      }
+#endif
 
       SEXP name = Rf_mkCharCE(it->name(), CE_UTF8);
       SET_STRING_ELT(names, i, name);