rb_sprintf implementation for VALUE arguments.

Author: aardvark179

lib/cext/include/ruby/ruby.h

@@ -137,7 +137,7 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1];
 #define PRIuVALUE               PRI_VALUE_PREFIX"u"
 #define PRIxVALUE               PRI_VALUE_PREFIX"x"
 #define PRIXVALUE               PRI_VALUE_PREFIX"X"
-#define PRIsVALUE               PRI_VALUE_PREFIX"i" RUBY_PRI_VALUE_MARK
+#define PRIsVALUE               "Y"
 
 
 #ifndef PRI_TIMET_PREFIX

lib/cext/include/truffleruby/truffleruby.h

@@ -18,9 +18,6 @@
 extern "C" {
 #endif
 
-#define rb_sprintf(format, ...) \
-  rb_tr_wrap(polyglot_invoke(RUBY_CEXT, "rb_sprintf", rb_tr_unwrap(rb_str_new_cstr(format)), ##__VA_ARGS__))
-
 NORETURN(VALUE rb_f_notimplement(int args_count, const VALUE *args, VALUE object));
 
 // Non-standard
@@ -83,13 +80,13 @@ typedef void *(*gvl_call)(void *);
 
 #define rb_warn(FORMAT, ...) do { \
 if (polyglot_as_boolean(polyglot_invoke(RUBY_CEXT, "warn?"))) { \
-  polyglot_invoke(rb_tr_unwrap(rb_mKernel), "warn", (VALUE) polyglot_invoke(rb_tr_unwrap(rb_mKernel), "sprintf", rb_tr_unwrap(rb_str_new_cstr(FORMAT)), ##__VA_ARGS__)); \
+  RUBY_INVOKE(rb_mKernel, "warn", rb_sprintf(FORMAT, ##__VA_ARGS__));   \
 } \
 } while (0);
 
 #define rb_warning(FORMAT, ...) do { \
 if (polyglot_as_boolean(polyglot_invoke(RUBY_CEXT, "warning?"))) { \
-  polyglot_invoke(rb_tr_unwrap(rb_mKernel), "warn", (VALUE) polyglot_invoke(rb_tr_unwrap(rb_mKernel), "sprintf", rb_tr_unwrap(rb_str_new_cstr(FORMAT)), ##__VA_ARGS__)); \
+  RUBY_INVOKE(rb_mKernel, "warn", rb_sprintf(FORMAT, ##__VA_ARGS__)); \
 } \
 } while (0);
 
@@ -153,7 +150,7 @@ MUST_INLINE int rb_tr_scan_args(int argc, VALUE *argv, const char *format, VALUE
 // Exceptions
 
 #define rb_raise(EXCEPTION, FORMAT, ...) \
-  rb_exc_raise(rb_exc_new_str(EXCEPTION, (VALUE) rb_tr_wrap(polyglot_invoke(RUBY_CEXT, "rb_sprintf", rb_tr_unwrap(rb_str_new_cstr(FORMAT)), ##__VA_ARGS__))))
+  rb_exc_raise(rb_exc_new_str(EXCEPTION, rb_sprintf(FORMAT, ##__VA_ARGS__)))
 
 // Additional non-standard
 VALUE rb_java_class_of(VALUE val);

lib/truffle/truffle/cext.rb

@@ -365,6 +365,8 @@ def RB_TYPE_P(value, type)
       value.is_a?(Data)
     when T_FLOAT
       value.is_a?(Float)
+    when T_CLASS
+      value.is_a?(Class)
     else
       raise "unknown type #{type}"
     end

spec/ruby/optional/capi/ext/string_spec.c

@@ -358,6 +358,14 @@ static VALUE string_spec_rb_sprintf2(VALUE self, VALUE str, VALUE repl1, VALUE r
   return rb_sprintf(RSTRING_PTR(str), RSTRING_PTR(repl1), RSTRING_PTR(repl2));
 }
 
+static VALUE string_spec_rb_sprintf3(VALUE self, VALUE str) {
+  return rb_sprintf("Result: %"PRIsVALUE".", str);
+}
+  
+static VALUE string_spec_rb_sprintf4(VALUE self, VALUE str) {
+  return rb_sprintf("Result: %+"PRIsVALUE".", str);
+}
+  
 static VALUE string_spec_rb_vsprintf_worker(char* fmt, ...) {
   va_list varargs;
   VALUE str;
@@ -463,6 +471,8 @@ void Init_string_spec(void) {
   rb_define_method(cls, "rb_str_free", string_spec_rb_str_free, 1);
   rb_define_method(cls, "rb_sprintf1", string_spec_rb_sprintf1, 2);
   rb_define_method(cls, "rb_sprintf2", string_spec_rb_sprintf2, 3);
+  rb_define_method(cls, "rb_sprintf3", string_spec_rb_sprintf3, 1);
+  rb_define_method(cls, "rb_sprintf4", string_spec_rb_sprintf4, 1);
   rb_define_method(cls, "rb_vsprintf", string_spec_rb_vsprintf, 4);
   rb_define_method(cls, "rb_str_equal", string_spec_rb_str_equal, 2);
   rb_define_method(cls, "rb_usascii_str_new", string_spec_rb_usascii_str_new, 2);

spec/ruby/optional/capi/string_spec.rb

@@ -32,6 +32,16 @@ def to_str
     end
   end
 
+  class ToSOrInspect
+    def to_s
+      'A string'
+    end
+
+    def inspect
+      'A different string'
+    end
+  end
+
   [Encoding::BINARY, Encoding::UTF_8].each do |enc|
     describe "rb_str_set_len on a #{enc.name} String" do
       before :each do
@@ -875,6 +885,16 @@ def to_str
       s = "Awesome %s is here with %s"
       @s.rb_sprintf2(s, "string", "content").should == "Awesome string is here with content"
     end
+
+    it "formats a string VALUE using to_s if sign not specified in format" do
+      s = 'Result: A string.'
+      @s.rb_sprintf3(ToSOrInspect.new).should == s
+    end
+
+    it "formats a string VALUE using to inspect if sign specified in format" do
+      s = 'Result: A different string.'
+      @s.rb_sprintf4(ToSOrInspect.new).should == s
+    end
   end
 
   describe "rb_vsprintf" do

src/main/c/cext/ruby.c

@@ -24,6 +24,7 @@
 #include <stdio.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <printf.h>
 
 void* rb_tr_cext;
 void* rb_tr_undef;
@@ -33,12 +34,78 @@ void* rb_tr_nil;
 
 // Run when loading C-extension support
 
+#ifdef __APPLE__
+static printf_domain_t printf_domain;
+
+static int rb_tr_fprintf_value_arginfo(const struct printf_info *info,
+                                       size_t n,
+                                       int *argtypes) {
+  if (n > 0) {
+    *argtypes = PA_POINTER;
+  }
+  return 1;
+}
+
+#else
+static int rb_tr_fprintf_value_arginfo(const struct printf_info *info,
+                                       size_t n,
+                                       int *argtypes, int *argsize) {
+  if (n > 0) {
+    *argtypes = PA_POINTER;
+    *argsize = sizeof(VALUE);
+  }
+  return 1;
+}
+#endif
+
+static int rb_tr_fprintf_value(FILE *stream,
+                               const struct printf_info *info,
+                               const void *const *args) {
+  char *cstr = NULL;
+  VALUE v;
+  int len;
+
+  v = *((const VALUE *) (args[0]));
+  if (info->showsign) {
+    if(RB_TYPE_P(v, T_CLASS)) {
+      if (v == rb_cNilClass) {
+        cstr = "nil";
+      } else if (v == rb_cInteger) {
+        cstr = "Integer";
+      } else if (v == rb_cSymbol) {
+        cstr = "Symbol";
+      } else if (v == rb_cTrueClass) {
+        cstr = "true";
+      } else if (v == rb_cFalseClass) {
+        cstr = "false";
+      }
+    }
+    if (cstr == NULL) {
+      VALUE str = rb_inspect(v);
+      len = rb_str_len(str);
+      cstr = RSTRING_PTR(str);
+    }
+  } else {
+    VALUE str = rb_obj_as_string(v);
+    len = rb_str_len(str);
+    cstr = RSTRING_PTR(str);
+  }
+  len = fprintf(stream, "%s", cstr);
+  return len;
+}
+
 void rb_tr_init(void *ruby_cext) {
   truffle_assign_managed(&rb_tr_cext, ruby_cext);
   truffle_assign_managed(&rb_tr_undef, rb_tr_get_undef());
   truffle_assign_managed(&rb_tr_true, rb_tr_get_true());
   truffle_assign_managed(&rb_tr_false, rb_tr_get_false());
   truffle_assign_managed(&rb_tr_nil, rb_tr_get_nil());
+  #ifdef __APPLE__
+  printf_domain = new_printf_domain();
+  register_printf_domain_function(printf_domain, 'Y', rb_tr_fprintf_value, rb_tr_fprintf_value_arginfo);  
+  #else
+  register_printf_specifier('Y', rb_tr_fprintf_value, rb_tr_fprintf_value_arginfo);
+  #endif
 }
 
 // Private helper macros just for ruby.c
@@ -844,6 +911,18 @@ VALUE rb_str_buf_new(long capacity) {
   return str;
 }
 
+VALUE rb_sprintf(const char *format, ...)
+{
+    VALUE result;
+    va_list ap;
+
+    va_start(ap, format);
+    result = rb_vsprintf(format, ap);
+    va_end(ap);
+
+    return result;
+}
+
 VALUE rb_vsprintf(const char *format, va_list args) {
   return rb_enc_vsprintf(rb_ascii8bit_encoding(), format, args);
 }
@@ -2282,7 +2361,7 @@ VALUE rb_range_beg_len(VALUE range, long *begp, long *lenp, long len, int err) {
 
 out_of_range:
   if (err) {
-    rb_raise(rb_eRangeError, "%d..%s%d out of range",
+    rb_raise(rb_eRangeError, "%ld..%s%ld out of range",
              origbeg, excl ? "." : "", origend);
   }
   return Qnil;
@@ -3053,9 +3132,12 @@ VALUE rb_enc_reg_new(const char *s, long len, rb_encoding *enc, int options) {
 }
 
 VALUE rb_enc_vsprintf(rb_encoding *enc, const char *format, va_list args) {
-  // TODO CS 7-May-17 this needs to use the Ruby sprintf, not C's
   char *buffer;
+  #ifdef __APPLE__
+  if (vasxprintf(&buffer, printf_domain, NULL, format, args) < 0) {
+  #else
   if (vasprintf(&buffer, format, args) < 0) {
+  #endif
     rb_tr_error("vasprintf error");
   }
   VALUE string = rb_enc_str_new_cstr(buffer, enc);