[GR-20329] Implement ONIGENC_MBC_CASE_FOLD.

PullRequest: truffleruby/1726

Author: bjfish

CHANGELOG.md

@@ -56,6 +56,7 @@ Compatibility:
 * Implemented `rb_enc_mbc_to_codepoint`.
 * Change the lookup methods to achieve Refinements specification (#2033, @ssnickolay)
 * Implemented `Digest::Instance#new` (#2040).
+* Implemented `ONIGENC_MBC_CASE_FOLD`.
 
 Performance:
 

lib/cext/include/ruby/encoding.h

@@ -253,6 +253,11 @@ int rb_enc_isspace(unsigned char c, rb_encoding *enc);
 #endif
 #define rb_enc_isdigit(c,enc) ONIGENC_IS_CODE_DIGIT((enc),(c))
 
+#ifdef TRUFFLERUBY
+/* This should be moved to onigmo.h when rb_encoding is typedef const OnigEncodingType rb_encoding; */
+int rb_tr_enc_mbc_case_fold(rb_encoding *enc, int flag, const UChar** p, const UChar* end, UChar* lower);
+#endif
+
 int rb_enc_asciicompat(rb_encoding *enc);
 
 int rb_enc_casefold(char *to, const char *p, const char *e, rb_encoding *enc);

lib/cext/include/ruby/onigmo.h

@@ -329,8 +329,13 @@ int onigenc_ascii_only_case_map(OnigCaseFoldType* flagP, const OnigUChar** pp, c
 
 #define ONIGENC_NAME(enc)                      ((enc)->name)
 
+#ifdef TRUFFLERUBY
+#define ONIGENC_MBC_CASE_FOLD(enc,flag,pp,end,buf) \
+  rb_tr_enc_mbc_case_fold(enc,flag,pp,end,buf)
+#else
 #define ONIGENC_MBC_CASE_FOLD(enc,flag,pp,end,buf) \
   (enc)->mbc_case_fold(flag,(const OnigUChar** )pp,end,buf,enc)
+#endif
 #define ONIGENC_IS_ALLOWED_REVERSE_MATCH(enc,s,end) \
         (enc)->is_allowed_reverse_match(s,end,enc)
 #define ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc,start,s,end) \

spec/ruby/optional/capi/encoding_spec.rb

@@ -610,4 +610,17 @@
       end
     end
   end
+
+  describe "ONIGENC_MBC_CASE_FOLD" do
+    it "returns the correct case fold for the given string" do
+      @s.ONIGENC_MBC_CASE_FOLD("lower").should == ["l", 1]
+      @s.ONIGENC_MBC_CASE_FOLD("Upper").should == ["u", 1]
+    end
+
+    it "works with other encodings" do
+      @s.ONIGENC_MBC_CASE_FOLD("lower".force_encoding("binary")).should == ["l", 1]
+      @s.ONIGENC_MBC_CASE_FOLD("Upper".force_encoding("binary")).should == ["u", 1]
+      @s.ONIGENC_MBC_CASE_FOLD("É").should == ["é", 2]
+    end
+  end
 end

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

@@ -266,6 +266,18 @@ static VALUE encoding_spec_rb_uv_to_utf8(VALUE self, VALUE buf, VALUE num) {
   return INT2NUM(rb_uv_to_utf8(RSTRING_PTR(buf), NUM2INT(num)));
 }
 
+static VALUE encoding_spec_ONIGENC_MBC_CASE_FOLD(VALUE self, VALUE str) {
+  char *beg = RSTRING_PTR(str);
+  char *beg_initial = beg;
+  char *end = beg + 2;
+  OnigUChar fold[ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM];
+  rb_encoding *enc = rb_enc_get(str);
+  int r = ONIGENC_MBC_CASE_FOLD(enc, ONIGENC_CASE_FOLD, &beg, (const OnigUChar *)end, fold);
+  VALUE str_result = r <= 0 ? Qnil : rb_enc_str_new((char *)fold, r, enc);
+  long bytes_used = beg - beg_initial;
+  return rb_ary_new3(2, str_result, INT2FIX(bytes_used));
+}
+
 void Init_encoding_spec(void) {
   VALUE cls;
   native_rb_encoding_pointer = (rb_encoding**) malloc(sizeof(rb_encoding*));
@@ -326,6 +338,7 @@ void Init_encoding_spec(void) {
   rb_define_method(cls, "rb_enc_codepoint_len", encoding_spec_rb_enc_codepoint_len, 1);
   rb_define_method(cls, "rb_enc_str_asciionly_p", encoding_spec_rb_enc_str_asciionly_p, 1);
   rb_define_method(cls, "rb_uv_to_utf8", encoding_spec_rb_uv_to_utf8, 2);
+  rb_define_method(cls, "ONIGENC_MBC_CASE_FOLD", encoding_spec_ONIGENC_MBC_CASE_FOLD, 1);
 }
 
 #ifdef __cplusplus

src/main/c/cext/encoding.c

@@ -331,3 +331,22 @@ int rb_uv_to_utf8(char buf[6], unsigned long uv) {
 
   rb_raise(rb_eRangeError, "pack(U): value out of range");
 }
+
+void write_p(const UChar** p, int offset) {
+  *p = *p + offset;
+}
+
+int rb_tr_enc_mbc_case_fold(rb_encoding *enc, int flag, const UChar** p, const UChar* end, UChar* result) {
+  int length = end - *p;
+  VALUE result_str = rb_tr_wrap(polyglot_invoke(RUBY_CEXT, "rb_tr_enc_mbc_case_fold",
+          rb_tr_unwrap(rb_enc_from_encoding(enc)),
+          flag,
+          rb_tr_unwrap(rb_str_new((char *)*p, length)),
+          write_p,
+          p));
+   int result_len = RSTRING_LEN(result_str);
+   if (result_len > 0) {
+     strncpy((char *)result, RSTRING_PTR(result_str), result_len);
+   }
+   return result_len;
+}

src/main/java/org/truffleruby/cext/CExtNodes.java

@@ -15,6 +15,8 @@
 import java.util.concurrent.locks.ReentrantLock;
 
 import org.jcodings.Encoding;
+import org.jcodings.IntHolder;
+import org.jcodings.specific.USASCIIEncoding;
 import org.jcodings.specific.UTF8Encoding;
 import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
@@ -1252,6 +1254,51 @@ protected Object mbclenCharFoundLen(int r) {
 
     }
 
+    @CoreMethod(names = "rb_tr_enc_mbc_case_fold", onSingleton = true, required = 5, lowerFixnum = 2)
+    public abstract static class RbTrMbcCaseFoldNode extends CoreMethodArrayArgumentsNode {
+
+        @Specialization(guards = { "isRubyString(string)", "isRubyEncoding(enc)" }, limit = "getCacheLimit()")
+        protected Object rbTrEncMbcCaseFold(
+                DynamicObject enc,
+                int flags,
+                DynamicObject string,
+                Object write_p,
+                Object p,
+                @CachedLibrary("write_p") InteropLibrary receivers,
+                @Cached BranchProfile exceptionProfile) {
+            final byte[] bytes = StringOperations.rope(string).getBytes();
+            final byte[] to = new byte[bytes.length];
+            final IntHolder intHolder = new IntHolder();
+            intHolder.value = 0;
+            final int resultLength = EncodingOperations
+                    .getEncoding(enc)
+                    .mbcCaseFold(flags, bytes, intHolder, bytes.length, to);
+            execute(write_p, new Object[]{ p, intHolder.value }, receivers, exceptionProfile);
+            final byte[] result = new byte[resultLength];
+            if (resultLength > 0) {
+                System.arraycopy(to, 0, result, 0, resultLength);
+            }
+            return StringOperations.createString(
+                    getContext(),
+                    RopeOperations.create(result, USASCIIEncoding.INSTANCE, CodeRange.CR_UNKNOWN));
+        }
+
+        private void execute(Object receiver, Object[] args, InteropLibrary receivers,
+                BranchProfile exceptionProfile) {
+            try {
+                receivers.execute(receiver, args);
+            } catch (UnsupportedTypeException | ArityException | UnsupportedMessageException e) {
+                exceptionProfile.enter();
+                throw new JavaException(e);
+            }
+        }
+
+        protected int getCacheLimit() {
+            return getContext().getOptions().DISPATCH_CACHE;
+        }
+
+    }
+
     @CoreMethod(names = "rb_enc_mbmaxlen", onSingleton = true, required = 1)
     public abstract static class RbEncMaxLenNode extends CoreMethodArrayArgumentsNode {