Implement wrapper to expose bytes-like object as Java byte[]

Author: fangerer

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/JavaModuleBuiltins.java

@@ -51,6 +51,7 @@
 import com.oracle.graal.python.builtins.PythonBuiltinClassType;
 import com.oracle.graal.python.builtins.PythonBuiltins;
 import com.oracle.graal.python.builtins.objects.PNone;
+import com.oracle.graal.python.builtins.objects.bytes.PBytesLike;
 import com.oracle.graal.python.builtins.objects.module.PythonModule;
 import com.oracle.graal.python.builtins.objects.object.PythonObjectLibrary;
 import com.oracle.graal.python.builtins.objects.str.PString;
@@ -63,6 +64,7 @@
 import com.oracle.graal.python.nodes.util.CastToJavaStringNode;
 import com.oracle.graal.python.runtime.PythonCore;
 import com.oracle.graal.python.runtime.exception.PythonErrorType;
+import com.oracle.graal.python.runtime.interop.InteropByteArray;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.TruffleLanguage.Env;
@@ -72,8 +74,13 @@
 import com.oracle.truffle.api.dsl.NodeFactory;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.interop.InvalidArrayIndexException;
 import com.oracle.truffle.api.interop.TruffleObject;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.library.CachedLibrary;
+import com.oracle.truffle.api.library.ExportLibrary;
+import com.oracle.truffle.api.library.ExportMessage;
 
 @CoreFunctions(defineModule = JavaModuleBuiltins.JAVA)
 public class JavaModuleBuiltins extends PythonBuiltins {
@@ -259,4 +266,92 @@ Object none(VirtualFrame frame, PythonModule mod, Object name,
             return lib.callObject(getAttr(frame, mod, lib), frame, name);
         }
     }
+
+    @Builtin(name = "as_java_byte_array", minNumOfPositionalArgs = 1)
+    @GenerateNodeFactory
+    abstract static class AsJavaByteArrayNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        static Object doBytesByteStorage(PBytesLike object) {
+            return new PUnsignedBytesWrapper(object);
+        }
+
+        @Specialization(guards = "lib.isBuffer(object)", limit = "3")
+        static Object doBuffer(Object object,
+                        @CachedLibrary("object") PythonObjectLibrary lib) {
+            try {
+                return new InteropByteArray(lib.getBufferBytes(object));
+            } catch (UnsupportedMessageException e) {
+                throw CompilerDirectives.shouldNotReachHere();
+            }
+        }
+
+        @Fallback
+        Object doError(Object object) {
+            throw raise(PythonBuiltinClassType.TypeError, ErrorMessages.BYTESLIKE_OBJ_REQUIRED, object);
+        }
+    }
+
+    /**
+     * A simple wrapper object that bit-casts an integer in range {@code 0-255} to a Java
+     * {@code byte}. This can be used to expose a bytes-like object to Java as {@code byte[]}.
+     */
+    @ExportLibrary(value = InteropLibrary.class, delegateTo = "delegate")
+    @SuppressWarnings("static-method")
+    static final class PUnsignedBytesWrapper implements TruffleObject {
+        final PBytesLike delegate;
+
+        PUnsignedBytesWrapper(PBytesLike delegate) {
+            this.delegate = delegate;
+        }
+
+        @ExportMessage
+        boolean hasArrayElements(
+                        @CachedLibrary("this.delegate") InteropLibrary delegateLib) {
+            return delegateLib.hasArrayElements(delegate);
+        }
+
+        @ExportMessage
+        boolean isArrayElementReadable(long index,
+                        @CachedLibrary("this.delegate") InteropLibrary delegateLib) {
+            return delegateLib.isArrayElementReadable(delegate, index);
+        }
+
+        @ExportMessage
+        long getArraySize(
+                        @CachedLibrary("this.delegate") InteropLibrary delegateLib) throws UnsupportedMessageException {
+            return delegateLib.getArraySize(delegate);
+        }
+
+        @ExportMessage
+        Object readArrayElement(long index,
+                        @CachedLibrary("this.delegate") InteropLibrary delegateLib,
+                        @CachedLibrary(limit = "1") InteropLibrary elementLib) throws InvalidArrayIndexException, UnsupportedMessageException {
+            Object element = delegateLib.readArrayElement(delegate, index);
+            if (elementLib.fitsInLong(element)) {
+                long i = elementLib.asLong(element);
+                if (compareUnsigned(i, Byte.MAX_VALUE) <= 0) {
+                    return (byte) i;
+                } else if (compareUnsigned(i, 0xFF) <= 0) {
+                    return (byte) -(-i & 0xFF);
+                }
+            }
+            throw CompilerDirectives.shouldNotReachHere("bytes object contains non-byte values");
+        }
+
+        /**
+         * This is taken from {@link Long#compare(long, long)}} (just to avoid a
+         * {@code TruffleBoundary}).
+         */
+        private static int compare(long x, long y) {
+            return (x < y) ? -1 : ((x == y) ? 0 : 1);
+        }
+
+        /**
+         * This is taken from {@link Long#compareUnsigned(long, long)}} (just to avoid a
+         * {@code TruffleBoundary}).
+         */
+        private static int compareUnsigned(long x, long y) {
+            return compare(x + Long.MIN_VALUE, y + Long.MIN_VALUE);
+        }
+    }
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/interop/InteropByteArray.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.graal.python.runtime.interop;
+
+import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
+import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.interop.TruffleObject;
+import com.oracle.truffle.api.library.ExportLibrary;
+import com.oracle.truffle.api.library.ExportMessage;
+
+@ExportLibrary(InteropLibrary.class)
+@SuppressWarnings("static-method")
+public final class InteropByteArray implements TruffleObject {
+    @CompilationFinal(dimensions = 1) private final byte[] array;
+
+    public InteropByteArray(byte[] array) {
+        this.array = array;
+    }
+
+    @ExportMessage
+    Object readArrayElement(long idx) {
+        return array[(int) idx];
+    }
+
+    @ExportMessage
+    long getArraySize() {
+        return array.length;
+    }
+
+    @ExportMessage
+    boolean hasArrayElements() {
+        return true;
+    }
+
+    @ExportMessage
+    boolean isArrayElementReadable(long idx) {
+        return idx < array.length;
+    }
+}