jruby · Mar 26, 2015 · Mar 26, 2015
diff --git a/spec/truffle/tags/core/encoding/converter/primitive_errinfo_tags.txt b/spec/truffle/tags/core/encoding/converter/primitive_errinfo_tags.txt
@@ -1,4 +1,3 @@
-fails:Encoding::Converter#primitive_errinfo returns [:source_buffer_empty,nil,nil,nil,nil] when no conversion has been attempted
 fails:Encoding::Converter#primitive_errinfo returns [:finished,nil,nil,nil,nil] when #primitive_convert last returned :finished
 fails:Encoding::Converter#primitive_errinfo returns [:source_buffer_empty,nil,nil,nil, nil] when #convert last succeeded
 fails:Encoding::Converter#primitive_errinfo returns [:destination_buffer_full,nil,nil,nil,nil] when #primitive_convert last returned :destination_buffer_full

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingConverterNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingConverterNodes.java
@@ -85,7 +85,8 @@ public RubyArray convpath(RubyEncodingConverter converter) {
 
     }
 
-    @CoreMethod(names = "initialize", required = 2, optional = 1)
+    @RubiniusOnly
+    @CoreMethod(names = "initialize_jruby", required = 2, optional = 1)
     public abstract static class InitializeNode extends CoreMethodNode {
 
         public InitializeNode(RubyContext context, SourceSection sourceSection) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/EncodingConverterPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/EncodingConverterPrimitiveNodes.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2015 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.nodes.rubinius;
+
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.source.SourceSection;
+import org.jcodings.Encoding;
+import org.jcodings.transcode.EConv;
+import org.jruby.Ruby;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.core.RubyArray;
+import org.jruby.truffle.runtime.core.RubyBasicObject;
+import org.jruby.truffle.runtime.core.RubyEncoding;
+import org.jruby.truffle.runtime.core.RubyEncodingConverter;
+import org.jruby.truffle.runtime.core.RubyHash;
+import org.jruby.truffle.runtime.core.RubyString;
+import org.jruby.util.ByteList;
+import org.jruby.util.io.EncodingUtils;
+
+/**
+ * Rubinius primitives associated with the Ruby {@code Encoding::Converter} class..
+ */
+public abstract class EncodingConverterPrimitiveNodes {
+
+    @RubiniusPrimitive(name = "encoding_converter_allocate")
+    public static abstract class EncodingConverterAllocateNode extends RubiniusPrimitiveNode {
+
+        public EncodingConverterAllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public EncodingConverterAllocateNode(EncodingConverterAllocateNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public Object encodingConverterAllocate(RubyEncoding fromEncoding, RubyEncoding toEncoding, RubyHash options) {
+            return new RubyEncodingConverter(getContext().getCoreLibrary().getEncodingConverterClass(), null);
+        }
+
+    }
+
+    @RubiniusPrimitive(name = "encoding_converter_primitive_convert")
+    public static abstract class EncodingConverterPrimitiveConvertNode extends RubiniusPrimitiveNode {
+
+        public EncodingConverterPrimitiveConvertNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public EncodingConverterPrimitiveConvertNode(EncodingConverterPrimitiveConvertNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public Object encodingConverterPrimitiveConvert(RubyBasicObject encodingConverter, RubyString source,
+                                                        RubyString target, int offset, int size, RubyHash options) {
+            throw new UnsupportedOperationException("not implemented");
+        }
+
+    }
+
+    @RubiniusPrimitive(name = "encoding_converter_putback")
+    public static abstract class EncodingConverterPutbackNode extends RubiniusPrimitiveNode {
+
+        public EncodingConverterPutbackNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public EncodingConverterPutbackNode(EncodingConverterPutbackNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public Object encodingConverterPutback(RubyBasicObject encodingConverter, int maxBytes) {
+            throw new UnsupportedOperationException("not implemented");
+        }
+
+    }
+
+    @RubiniusPrimitive(name = "encoding_converter_last_error")
+    public static abstract class EncodingConverterLastErrorNode extends RubiniusPrimitiveNode {
+
+        public EncodingConverterLastErrorNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public EncodingConverterLastErrorNode(EncodingConverterLastErrorNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public Object encodingConverterLastError(RubyBasicObject encodingConverter) {
+            throw new UnsupportedOperationException("not implemented");
+        }
+
+    }
+
+    @RubiniusPrimitive(name = "encoding_converter_primitive_errinfo")
+    public static abstract class EncodingConverterErrinfoNode extends RubiniusPrimitiveNode {
+
+        public EncodingConverterErrinfoNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public EncodingConverterErrinfoNode(EncodingConverterErrinfoNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public Object encodingConverterLastError(RubyEncodingConverter encodingConverter) {
+            notDesignedForCompilation();
+
+            final EConv ec = encodingConverter.getEConv();
+
+            final Object[] ret = { getContext().newSymbol(ec.lastError.getResult().symbolicName()), nil(), nil(), nil(), nil() };
+
+            if (ec.lastError.getSource() != null) {
+                ret[1] = getContext().makeString(new ByteList(ec.lastError.getSource()));
+            }
+
+            if (ec.lastError.getDestination() != null) {
+                ret[2] = getContext().makeString(new ByteList(ec.lastError.getDestination()));
+            }
+
+            if (ec.lastError.getErrorBytes() != null) {
+                ret[3] = getContext().makeString(new ByteList(ec.lastError.getErrorBytes(), ec.lastError.getErrorBytesP(), ec.lastError.getErrorBytesLength()));
+                ret[4] = getContext().makeString(new ByteList(ec.lastError.getErrorBytes(), ec.lastError.getErrorBytesP() + ec.lastError.getErrorBytesLength(), ec.lastError.getReadAgainLength()));
+            }
+
+            return new RubyArray(getContext().getCoreLibrary().getArrayClass(), ret, ret.length);
+        }
+
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/EncodingPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/EncodingPrimitiveNodes.java
@@ -20,97 +20,6 @@
  */
 public abstract class EncodingPrimitiveNodes {
 
-    @RubiniusPrimitive(name = "encoding_converter_allocate")
-    public static abstract class EncodingConverterAllocateNode extends RubiniusPrimitiveNode {
-
-        public EncodingConverterAllocateNode(RubyContext context, SourceSection sourceSection) {
-            super(context, sourceSection);
-        }
-
-        public EncodingConverterAllocateNode(EncodingConverterAllocateNode prev) {
-            super(prev);
-        }
-
-        @Specialization
-        public Object encodingConverterAllocate(RubyEncoding fromEncoding, RubyEncoding toEncoding, RubyHash options) {
-            return new RubyEncodingConverter(getContext().getCoreLibrary().getEncodingConverterClass(), null);
-        }
-
-    }
-
-    @RubiniusPrimitive(name = "encoding_converter_primitive_convert")
-    public static abstract class EncodingConverterPrimitiveConvertNode extends RubiniusPrimitiveNode {
-
-        public EncodingConverterPrimitiveConvertNode(RubyContext context, SourceSection sourceSection) {
-            super(context, sourceSection);
-        }
-
-        public EncodingConverterPrimitiveConvertNode(EncodingConverterPrimitiveConvertNode prev) {
-            super(prev);
-        }
-
-        @Specialization
-        public Object encodingConverterPrimitiveConvert(RubyBasicObject encodingConverter, RubyString source,
-                                                        RubyString target, int offset, int size, RubyHash options) {
-            throw new UnsupportedOperationException("not implemented");
-        }
-
-    }
-
-    @RubiniusPrimitive(name = "encoding_converter_putback")
-    public static abstract class EncodingConverterPutbackNode extends RubiniusPrimitiveNode {
-
-        public EncodingConverterPutbackNode(RubyContext context, SourceSection sourceSection) {
-            super(context, sourceSection);
-        }
-
-        public EncodingConverterPutbackNode(EncodingConverterPutbackNode prev) {
-            super(prev);
-        }
-
-        @Specialization
-        public Object encodingConverterPutback(RubyBasicObject encodingConverter, int maxBytes) {
-            throw new UnsupportedOperationException("not implemented");
-        }
-
-    }
-
-    @RubiniusPrimitive(name = "encoding_converter_last_error")
-    public static abstract class EncodingConverterLastErrorNode extends RubiniusPrimitiveNode {
-
-        public EncodingConverterLastErrorNode(RubyContext context, SourceSection sourceSection) {
-            super(context, sourceSection);
-        }
-
-        public EncodingConverterLastErrorNode(EncodingConverterLastErrorNode prev) {
-            super(prev);
-        }
-
-        @Specialization
-        public Object encodingConverterLastError(RubyBasicObject encodingConverter) {
-            throw new UnsupportedOperationException("not implemented");
-        }
-
-    }
-
-    @RubiniusPrimitive(name = "encoding_converter_primitive_errinfo")
-    public static abstract class EncodingConverterErrinfoNode extends RubiniusPrimitiveNode {
-
-        public EncodingConverterErrinfoNode(RubyContext context, SourceSection sourceSection) {
-            super(context, sourceSection);
-        }
-
-        public EncodingConverterErrinfoNode(EncodingConverterErrinfoNode prev) {
-            super(prev);
-        }
-
-        @Specialization
-        public Object encodingConverterLastError(RubyBasicObject encodingConverter) {
-            throw new UnsupportedOperationException("not implemented");
-        }
-
-    }
-
     @RubiniusPrimitive(name = "encoding_get_object_encoding", needsSelf = false)
     public static abstract class EncodingGetObjectEncodingNode extends RubiniusPrimitiveNode {
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/RubiniusPrimitiveManager.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/RubiniusPrimitiveManager.java
@@ -51,6 +51,7 @@ public static RubiniusPrimitiveManager create() {
         nodeFactories.addAll(BignumPrimitiveNodesFactory.getFactories());
         nodeFactories.addAll(FloatPrimitiveNodesFactory.getFactories());
         nodeFactories.addAll(EncodingPrimitiveNodesFactory.getFactories());
+        nodeFactories.addAll(EncodingConverterPrimitiveNodesFactory.getFactories());
         nodeFactories.addAll(RegexpPrimitiveNodesFactory.getFactories());
         nodeFactories.addAll(ModulePrimitiveNodesFactory.getFactories());
         nodeFactories.addAll(RandomPrimitiveNodesFactory.getFactories());

diff --git a/truffle/src/main/ruby/core/shims.rb b/truffle/src/main/ruby/core/shims.rb
@@ -237,3 +237,15 @@ def default_internal=(enc)
     end
   end
 end
+
+# We use Rubinius's encoding class hierarchy, but do the encoding conversion in Java.  In order to properly initialize
+# the converter, we need to initialize in both Rubinius and JRuby.
+class Encoding::Converter
+  alias_method :initialize_rubinius, :initialize
+
+  def initialize(*args)
+    initialize_rubinius(*args)
+    initialize_jruby(*args)
+  end
+end
+