rjb 1.5.9 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8eddc0f7bf9505a5f48e1098dd18f0133253986978599c40e5c39ce6cc48b90
-  data.tar.gz: 880d819371d1cb1c738c2db0c0395873d86391ecef8b056c7597aacf930598ce
+  metadata.gz: 7d1fbaad6b7b8881cdf6ca256139b8447590c578430e1775255fbc457e44f4aa
+  data.tar.gz: 5a3e4e5142eb5db86af1b9419f72e5128bb19975926a70c94e078e8553d6ccec
 SHA512:
-  metadata.gz: ad9b557b9ff3d9091663df6041b63672ba96a2e192f23deba2dbe6dfe94edf09f36176e8894b2e71c8194f68e6f4e23b1e67c9a7064c52c5dea5ce0723be9e14
-  data.tar.gz: 7da7f62f72373a83ef662ee62cd37c7fdac28a52c6fc059af337970a7249103858442c304b139945118371c2893ac6057404f619016d4cff758a5aabaffd80f2
+  metadata.gz: b4f7b723db8f2ce2415814e6689d26c4f38b221d75903767a9c0434cb0a1da0ba7c6b53fb58fdf7ba8a8861beea02c7cb80079b787f6702d5f03132b6fc09ea1
+  data.tar.gz: b1724e95cd003cc140c45f42916340bd90c7ce115933a5e83d1a31d3bf91504e2bea714600f7a430e1939083d8e1dbf29fac273eb26d1c4245ec2407cfb39abb

data/ext/extconf.h

@@ -4,5 +4,5 @@
 #define HAVE_NL_LANGINFO 1
 #define HAVE_SETLOCALE 1
 #define HAVE_GETENV 1
-#define RJB_RUBY_VERSION_CODE 261
+#define RJB_RUBY_VERSION_CODE 270
 #endif

data/ext/riconv.c

@@ -167,6 +167,126 @@ static void check_kcode()
         objIconvR2J = objIconvJ2R = Qnil;
     }
 }
+#else
+VALUE cEncoding = Qnil;
+VALUE encoding_utf8 = Qnil;
+static void init_encoding_vars()
+{
+    cEncoding = rb_const_get(rb_cObject, rb_intern("Encoding"));
+    encoding_utf8 = rb_const_get(cEncoding, rb_intern("UTF_8"));
+}
+static int contains_surrogate_pair(const unsigned char* p)
+{
+    while (*p)
+    {
+        switch (*p & 0xf0)
+        {
+        case 0xf0:
+            return 1;
+        case 0xe0:
+            p += 3;
+            break;
+        default:
+            p += (*p & 0x80) ? 2 : 1;
+        }
+    }
+    return 0;
+}
+static int contains_auxchar(const unsigned char* p)
+{
+    while (*p)
+    {
+      if (*p == 0xed)
+        {
+#if defined(DEBUG)
+          printf("find %02x %02x %02x %02x %02x %02x\n", *p, *(p + 1), *(p + 2), *(p + 3), *(p + 4), *(p + 5));
+#endif
+          return 1;
+        }
+        switch (*p & 0xe0)
+        {
+        case 0xe0:
+            p++;
+        case 0xc0:
+            p++;
+        default:
+            p++;
+        }
+    }
+    return 0;
+}
+
+static VALUE encode_to_cesu8(const unsigned char* p)
+{
+    size_t len = strlen(p);
+    char* newstr = ALLOCA_N(char, len + (len + 1) / 2);
+    char* dest = newstr;
+    int sval, i;
+    while (*p)
+    {
+        switch (*p & 0xf0)
+        {
+        case 0xf0:
+            sval = *p++ & 7;
+            for (i = 0; i < 3; i++)
+            {
+                sval <<= 6;
+                sval |= (*p++ & 0x3f);
+            }
+            *dest++ = '\xed';
+            *dest++ = 0xa0 | (((sval >> 16) - 1) & 0x0f);
+            *dest++ = 0x80 | ((sval >> 10) & 0x3f);
+            *dest++ = '\xed';
+            *dest++ = 0xb0 | ((sval >> 6) & 0x0f);
+            *dest++ = 0x80 | (sval & 0x3f);
+            break;
+        case 0xe0:
+            *dest++ = *p++;
+        case 0xc0:
+        case 0xc1:          
+            *dest++ = *p++;
+        default:
+            *dest++ = *p++;
+        }
+    }
+    return rb_str_new(newstr, dest - newstr);
+}
+static VALUE encode_to_utf8(const unsigned char* p)
+{
+    size_t len = strlen(p);
+    char* newstr = ALLOCA_N(char, len);
+    char* dest = newstr;
+    int sval, i;
+    while (*p)
+    {
+        if (*p == 0xed)
+        {
+            char v = *(p + 1);
+            char w = *(p + 2);
+            char y = *(p + 4);
+            char z = *(p + 5);
+            p += 6;
+            sval = 0x10000 + ((v & 0x0f) << 16) + ((w & 0x3f) << 10) + ((y & 0x0f) << 6) + (z & 0x3f);
+            sval = (((v + 1) & 0x0f) << 16) + ((w & 0x3f) << 10) + ((y & 0x0f) << 6) + (z & 0x3f);
+           *dest++ = 0xf0 | ((sval >> 18));
+           *dest++ = 0x80 | ((sval >> 12) & 0x3f);
+           *dest++ = 0x80 | ((sval >> 6) & 0x3f);
+           *dest++ = 0x80 | (sval & 0x3f);
+           continue;
+        }
+        switch (*p & 0xe0)
+        {
+        case 0xe0:
+            *dest++ = *p++;          
+        case 0xc0:
+        case 0xc1:          
+            *dest++ = *p++;                    
+        default:
+            *dest++ = *p++;                   
+        }
+    }
+    return rb_str_new(newstr, dest - newstr);
+}
 #endif
 
 #if defined(DEBUG)
@@ -177,6 +297,8 @@ static void debug_out(VALUE v)
            strlen(p), p);
     fflush(stdout);
 }
+#else
+#define debug_out(n)
 #endif
 
 VALUE exticonv_local_to_utf8(VALUE local_string)
@@ -192,23 +314,24 @@ VALUE exticonv_local_to_utf8(VALUE local_string)
         return local_string;
     }
 #else
-    VALUE cEncoding, encoding, utf8;
-    cEncoding = rb_const_get(rb_cObject, rb_intern("Encoding"));
+    VALUE encoding;
+    if (NIL_P(cEncoding))
+    {
+      init_encoding_vars();
+    }
     encoding = rb_funcall(local_string, rb_intern("encoding"), 0);
-    utf8 = rb_const_get(cEncoding, rb_intern("UTF_8"));
-    if (encoding != utf8)
+    if (encoding != encoding_utf8)
     {
-        VALUE ret = rb_funcall(local_string, rb_intern("encode"), 2, utf8, encoding);
-#if defined(DEBUG)
+        VALUE ret = rb_funcall(local_string, rb_intern("encode"), 2, encoding_utf8, encoding);
         debug_out(local_string);
         debug_out(ret);
-#endif        
-        return ret;
+        local_string = ret;
     }
-    else
+    if (contains_surrogate_pair(StringValuePtr(local_string)))
     {
-	return local_string;
+        local_string = encode_to_cesu8(StringValuePtr(local_string));
     }
+    return local_string;
 #endif
 }
 
@@ -225,6 +348,14 @@ VALUE exticonv_utf8_to_local(VALUE utf8_string)
         return utf8_string;
     }
 #else
-    return rb_funcall(utf8_string, rb_intern("force_encoding"), 1, rb_const_get(rb_cEncoding, rb_intern("UTF_8")));
+    if (NIL_P(cEncoding))
+    {
+        init_encoding_vars();
+    }
+    if (contains_auxchar(StringValuePtr(utf8_string)))
+    {
+        utf8_string = encode_to_utf8(StringValuePtr(utf8_string));
+    }
+    return rb_funcall(utf8_string, rb_intern("force_encoding"), 1, encoding_utf8);
 #endif
 }

data/ext/rjb.c

@@ -14,7 +14,7 @@
  *
  */
 
-#define RJB_VERSION "1.5.9"
+#define RJB_VERSION "1.6.0"
 
 #include "ruby.h"
 #include "extconf.h"

data/test/test.rb

@@ -216,17 +216,28 @@ class TestRjb < Test::Unit::TestCase
   end
 
   def test_combination_charcters
-    teststr = "\xc7\x96\xc3\xbc\xcc\x84\x75\xcc\x88\xcc\x84\xed\xa1\xa9\xed\xba\xb2\xe3\x81\x8b\xe3\x82\x9a"
+    teststr = "\xc7\x96\xc3\xbc\xcc\x84\x75\xcc\x88\xcc\x84𪚲\xe3\x81\x8b\xe3\x82\x9a"
     test = import('jp.co.infoseek.hp.arton.rjb.Test').new
     s = test.getUmlaut()
     if Object::const_defined?(:Encoding) #>=1.9
-      teststr = teststr.force_encoding(Encoding::UTF_8)
-      assert_equal(s, teststr)
+=begin
+      n = [teststr.bytes.length, s.bytes.length].max
+      puts "org:#{teststr.bytes.length}, ret:#{s.bytes.length}"
+      0.upto(n - 1) do |i|
+        b0 = teststr.getbyte(i)
+        b0 = 0 unless b0
+        b1 = s.getbyte(i)
+        b1 = 0 unless b1
+        puts sprintf("%02X - %02X\n", b0, b1)
+      end
+=end
+      assert_equal(teststr.bytes.length, s.bytes.length)
+      assert_equal(teststr, s)
     else
       default_kcode = $KCODE
       begin
 	$KCODE = "utf8"
-	assert_equal(s, teststr)
+	assert_equal(teststr, s)
       ensure
 	$KCODE = default_kcode
       end
@@ -947,5 +958,10 @@ class TestRjb < Test::Unit::TestCase
       end
     end
   end
+
+  def test_java_utf8
+    y = @jString.new('𠮷野家')
+    assert_equal '𠮷野家', y.toString
+  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rjb
 version: !ruby/object:Gem::Version
-  version: 1.5.9
+  version: 1.6.0
 platform: ruby
 authors:
 - arton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-17 00:00:00.000000000 Z
+date: 2019-07-10 00:00:00.000000000 Z
 dependencies: []
 description: 'RJB is a bridge program that connect between Ruby and Java with Java
   Native Interface.