Implement 'PyStructSequence_Set/GetItem'.

fangerer · fangerer · commit ca8b1b9142b8 · 2019-07-04T11:20:37.000+02:00
diff --git a/graalpython/com.oracle.graal.python.cext/include/tupleobject.h b/graalpython/com.oracle.graal.python.cext/include/tupleobject.h
@@ -30,7 +30,7 @@ returned item's reference count.
 typedef struct {
     PyObject_VAR_HEAD
     // Truffle change: PyObject *ob_item[1] doesn't work for us in Sulong
-    PyObject **ob_item;
+    PyObject *ob_item[];
 
     /* ob_item contains space for 'ob_size' elements.
      * Items must normally not be NULL, except during construction when
diff --git a/graalpython/com.oracle.graal.python.cext/src/capi.c b/graalpython/com.oracle.graal.python.cext/src/capi.c
@@ -402,6 +402,10 @@ PRIMITIVE_ARRAY_TO_NATIVE(Long, int64_t, i64, polyglot_as_i64);
 PRIMITIVE_ARRAY_TO_NATIVE(Double, double, double, polyglot_as_double);
 PRIMITIVE_ARRAY_TO_NATIVE(Object, PyObjectPtr, PyObjectPtr, (PyObjectPtr));
 
+Py_ssize_t PyTruffle_Object_Size(PyObject *op) {
+    return ((PyVarObject*)op)->ob_size;
+}
+
 #define ReadMember(object, offset, T) ((T*)(((char*)object) + offset))[0]
 
 int ReadShortMember(PyObject* object, Py_ssize_t offset) {
diff --git a/graalpython/com.oracle.graal.python.cext/src/structseq.c b/graalpython/com.oracle.graal.python.cext/src/structseq.c
@@ -48,10 +48,8 @@ PyObject* PyStructSequence_New(PyTypeObject* o) {
 
 UPCALL_ID(PyStructSequence_InitType2);
 int PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc) {
-    PyObject *dict;
-    PyMemberDef* members;
-    Py_ssize_t n_members, n_unnamed_members, i, k;
-    PyObject *v;
+    Py_ssize_t n_members = desc->n_in_sequence;
+    Py_ssize_t i;
 
     memset(type, 0, sizeof(PyTypeObject));
 
@@ -79,6 +77,7 @@ int PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc)
     type->tp_members = NULL;
     type->tp_new = newType->tp_new;
     type->tp_base = &PyTuple_Type;
+    type->tp_alloc = PyType_GenericAlloc;
 
     // now copy specific fields
     type->tp_name = newType->tp_name;
@@ -93,8 +92,40 @@ int PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc)
     return 0;
 }
 
+PyTypeObject* PyStructSequence_NewType(PyStructSequence_Desc *desc) {
+    Py_ssize_t n_members = desc->n_in_sequence;
+    Py_ssize_t i;
+
+    // put field names and doc strings into two tuples
+    PyObject* field_names = PyTuple_New(n_members);
+    PyObject* field_docs = PyTuple_New(n_members);
+    PyStructSequence_Field* fields = desc->fields;
+    for (i = 0; i < n_members; i++) {
+    	PyTuple_SetItem(field_names, i, polyglot_from_string(fields[i].name, SRC_CS));
+    	PyTuple_SetItem(field_docs, i, polyglot_from_string(fields[i].doc, SRC_CS));
+    }
+
+    // we create the new type managed
+    PyTypeObject* newType = (PyTypeObject*) UPCALL_CEXT_O(_jls_PyStructSequence_InitType2,
+    		polyglot_from_string(desc->name, SRC_CS),
+			polyglot_from_string(desc->doc, SRC_CS),
+			native_to_java(field_names),
+			native_to_java(field_docs));
+    return newType;
+}
+
 // taken from CPython "Objects/structseq.c"
 void PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc) {
     (void)PyStructSequence_InitType2(type, desc);
 }
 
+// taken from CPython "Objects/structseq.c"
+void PyStructSequence_SetItem(PyObject* op, Py_ssize_t i, PyObject* v) {
+    PyStructSequence_SET_ITEM(op, i, v);
+}
+
+// taken from CPython "Objects/structseq.c"
+PyObject* PyStructSequence_GetItem(PyObject* op, Py_ssize_t i) {
+	return PyStructSequence_GET_ITEM(op, i);
+}
+
diff --git a/graalpython/com.oracle.graal.python.cext/src/tupleobject.c b/graalpython/com.oracle.graal.python.cext/src/tupleobject.c
@@ -88,8 +88,10 @@ static PyObject * tuple_create(PyObject *iterable) {
     return PySequence_Tuple(iterable);
 }
 
+POLYGLOT_DECLARE_TYPE(PyTupleObject);
 PyObject * tuple_subtype_new(PyTypeObject *type, PyObject *iterable) {
-    PyObject *tmp, *newobj, *item;
+	PyTupleObject* newobj;
+    PyObject *tmp, *item;
     Py_ssize_t i, n;
 
     assert(PyType_IsSubtype(type, &PyTuple_Type));
@@ -100,15 +102,25 @@ PyObject * tuple_subtype_new(PyTypeObject *type, PyObject *iterable) {
     assert(PyTuple_Check(tmp));
     n = PyTuple_GET_SIZE(tmp);
 
-    newobj = type->tp_alloc(type, n);
+    newobj = (PyTupleObject*) type->tp_alloc(type, n);
     if (newobj == NULL) {
         return NULL;
     }
+    newobj = polyglot_from_PyTupleObject(newobj);
     for (i = 0; i < n; i++) {
         item = PyTuple_GetItem(tmp, i);
         Py_INCREF(item);
-        PyTuple_SetItem(newobj, i, item);
+        PyTuple_SetItem((PyObject*)newobj, i, item);
     }
     Py_DECREF(tmp);
-    return newobj;
+
+    // This polyglot type cast is important such that we can directly read and
+    // write members of the pointer from Java code.
+    // Note: the return type is 'PyObject*' to be compatible with CPython
+    return (PyObject*) newobj;
+}
+
+int PyTruffle_Tuple_SetItem(PyObject* tuple, Py_ssize_t position, PyObject* item) {
+    PyTuple_SET_ITEM(tuple, position, item);
+    return 0;
 }
diff --git a/graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_structseq.py b/graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_structseq.py
@@ -38,35 +38,65 @@
 # SOFTWARE.
 
 import sys
-from . import CPyExtTestCase, CPyExtFunction, CPyExtFunctionOutVars, unhandled_error_compare, GRAALPYTHON
+from . import CPyExtType, CPyExtTestCase, CPyExtFunction, CPyExtFunctionOutVars, unhandled_error_compare, GRAALPYTHON
 __dir__ = __file__.rpartition("/")[0]
 
+# 
+# class TestPyStructSequenceTypes(object):
+#     def test_properties(self):
+#         TestPyStructSequence = CPyExtType("TestPyStructSequence",
+#                                           """
+#                                static PyStructSequence_Field typeinfo_fields[] = {
+#                                    {"element0",      "The first element."},
+#                                    {"element1",      "The second element."},
+#                                    {NULL, NULL,}
+#                                };
+#            
+#                                static PyStructSequence_Desc typeinfo_desc = { 
+#                                    "TestPyStructSequenceTypes.TestPyStructSequence",
+#                                    "Information about some custom struct type",
+#                                    typeinfo_fields,
+#                                    2,
+#                                };
+#                                 """,
+#                                 ready_code="""if(PyStructSequence_InitType2(&TestPyStructSequenceType, &typeinfo_desc) < 0) {
+#                                  return NULL;
+#                              }
+#                              Py_INCREF(&TestPyStructSequenceType);
+#                              """,
+#         )
+#         assert TestPyStructSequence.__doc__ == "Information about some custom struct type"
+# 
+#         tester = TestPyStructSequence()
+#         assert hasattr(tester.element0)
+#         assert hasattr(tester.element1)
 
-class TestPyStructSequence(CPyExtTestCase):
 
+class TestPyStructSequence(CPyExtTestCase):
+ 
     def compile_module(self, name):
         type(self).mro()[1].__dict__["test_%s" % name].create_module(name)
         super(TestPyStructSequence, self).compile_module(name)
-
+ 
     test_PyStructSequence_InitType2 = CPyExtFunction(
         lambda args: 0,
         lambda: ( (0,), ),
         code='''
         static PyTypeObject CustomStructSeqType;
-        
+          
         static PyStructSequence_Field typeinfo_fields[] = {
             {"element0",      "The first element."},
             {"element1",      "The second element."},
             {NULL, NULL,}
         };
-        
+          
         static PyStructSequence_Desc typeinfo_desc = { 
             "custom.named.tuple",
             "Information about some custom struct type",
             typeinfo_fields,
             2,
         };
-        
+          
         int wrap_PyStructSequence_InitType2(int n) {
             return PyStructSequence_InitType2(&CustomStructSeqType, &typeinfo_desc);
         }
@@ -78,3 +108,64 @@ def compile_module(self, name):
         cmpfunc=unhandled_error_compare
     )
 
+    test_PyStructSequence_Usage = CPyExtFunction(
+        lambda args: args[0],
+        lambda: ( 
+            (("hello", "world",),),
+#             ("john", "doe",), 
+#             (1, "doe",), 
+#             ("john", False,), 
+#             ("john", None,), 
+        ),
+        code='''
+        static PyTypeObject CustomStructSeqType;
+
+        static PyStructSequence_Field typeinfo_fields[] = {
+            {"element0",      "The first element."},
+            {"element1",      "The second element."},
+            {NULL, NULL,}
+        };
+         
+        static PyStructSequence_Desc typeinfo_desc = { 
+            "custom.named.tuple",
+            "Information about some custom struct type",
+            typeinfo_fields,
+            2,
+        };
+         
+        PyObject* wrap_PyStructSequence_Usage(PyObject* elements) {
+            Py_ssize_t i = 0;
+            PyObject* elem = NULL;
+            Py_INCREF(elements);
+
+            PyStructSequence_InitType2(&CustomStructSeqType, &typeinfo_desc);
+
+            PyObject* struct_obj = PyStructSequence_New(&CustomStructSeqType);
+            if (struct_obj == NULL) {
+                return NULL;
+            }
+            for (i = 0; i < PyObject_Length(elements); i++) {
+                elem = PyTuple_GetItem(elements, i);
+                Py_INCREF(elem);
+                PyStructSequence_SetItem(struct_obj, i, elem);
+            }
+
+            PyObject* result = PyTuple_New(PyObject_Length(struct_obj));
+            if (result == NULL) {
+                return NULL;
+            }
+            for (i = 0; i < PyObject_Length(struct_obj); i++) {
+                elem = PyStructSequence_GetItem(struct_obj, i);
+                Py_INCREF(elem);
+                PyTuple_SetItem(result, i, elem);
+            }
+            Py_INCREF(result);
+            return result;
+        }
+        ''',
+        resultspec="O",
+        argspec='O',
+        arguments=["PyObject* elements"],
+        callfunction="wrap_PyStructSequence_Usage",
+        cmpfunc=unhandled_error_compare
+    )
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/PythonCextBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/PythonCextBuiltins.java
@@ -81,12 +81,14 @@
 import com.oracle.graal.python.builtins.objects.cext.CExtNodes.MayRaiseNodeFactory;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodes.MayRaiseTernaryNode;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodes.MayRaiseUnaryNode;
+import com.oracle.graal.python.builtins.objects.cext.CExtNodes.PCallCapiFunction;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory.MayRaiseBinaryNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory.MayRaiseTernaryNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodesFactory.MayRaiseUnaryNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.DynamicObjectNativeWrapper;
 import com.oracle.graal.python.builtins.objects.cext.HandleCache;
+import com.oracle.graal.python.builtins.objects.cext.NativeCAPISymbols;
 import com.oracle.graal.python.builtins.objects.cext.PThreadState;
 import com.oracle.graal.python.builtins.objects.cext.PySequenceArrayWrapper;
 import com.oracle.graal.python.builtins.objects.cext.PythonClassInitNativeWrapper;
@@ -324,12 +326,23 @@ PTuple doGeneric(Object size,
     @GenerateNodeFactory
     abstract static class PyTuple_SetItem extends PythonTernaryBuiltinNode {
         @Specialization
-        int doI(PTuple tuple, Object position, Object element,
+        int doManaged(PTuple tuple, Object position, Object element,
                         @Cached("createSetItem()") SequenceStorageNodes.SetItemNode setItemNode) {
             setItemNode.execute(tuple.getSequenceStorage(), position, element);
             return 0;
         }
 
+        @Specialization(limit = "1")
+        int doNative(PythonNativeObject tuple, long position, Object element,
+                        @Cached PCallCapiFunction callSetItem,
+                        @Cached CExtNodes.ToSulongNode receiverToSulongNode,
+                        @Cached CExtNodes.ToSulongNode elementToSulongNode) {
+            // TODO(fa): This path should be avoided since this is called from native code to do a
+            // native operation.
+            callSetItem.call(NativeCAPISymbols.FUN_PY_TRUFFLE_TUPLE_SET_ITEM, receiverToSulongNode.execute(tuple), position, elementToSulongNode.execute(element));
+            return 0;
+        }
+
         protected static SequenceStorageNodes.SetItemNode createSetItem() {
             return SequenceStorageNodes.SetItemNode.create(NormalizeIndexNode.forTupleAssign(), "invalid item for assignment");
         }
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeCAPISymbols.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeCAPISymbols.java
@@ -81,6 +81,8 @@ public abstract class NativeCAPISymbols {
     public static final String FUN_PY_OBJECT_GENERIC_NEW = "PyTruffle_Type_GenericNew";
     public static final String FUN_GET_THREAD_STATE_TYPE_ID = "get_thread_state_typeid";
     public static final String FUN_ADD_NATIVE_SLOTS = "PyTruffle_Type_AddSlots";
+    public static final String FUN_PY_TRUFFLE_TUPLE_SET_ITEM = "PyTruffle_Tuple_SetItem";
+    public static final String FUN_PY_TRUFFLE_OBJECT_SIZE = "PyTruffle_Object_Size";
 
     @CompilationFinal(dimensions = 1) private static final String[] values;
     static {
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/tuple/TupleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/tuple/TupleBuiltins.java
@@ -55,6 +55,10 @@
 import com.oracle.graal.python.builtins.modules.MathGuards;
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.PNotImplemented;
+import com.oracle.graal.python.builtins.objects.cext.CExtNodes;
+import com.oracle.graal.python.builtins.objects.cext.CExtNodes.PCallCapiFunction;
+import com.oracle.graal.python.builtins.objects.cext.NativeCAPISymbols;
+import com.oracle.graal.python.builtins.objects.cext.PythonNativeObject;
 import com.oracle.graal.python.builtins.objects.common.IndexNodes.NormalizeIndexNode;
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodes;
 import com.oracle.graal.python.builtins.objects.ints.PInt;
@@ -282,10 +286,18 @@ long count(VirtualFrame frame, PTuple self, Object value,
     @GenerateNodeFactory
     public abstract static class LenNode extends PythonUnaryBuiltinNode {
         @Specialization
-        public int len(PTuple self,
+        public int doManaged(PTuple self,
                         @Cached("create()") SequenceStorageNodes.LenNode lenNode) {
             return lenNode.execute(self.getSequenceStorage());
         }
+
+        @Specialization
+        public int doNative(PythonNativeObject self,
+                        @Cached PCallCapiFunction callSizeNode,
+                        @Cached CExtNodes.ToSulongNode toSulongNode,
+                        @Cached CastToJavaLongNode castToLongNode) {
+            return (int) castToLongNode.execute(callSizeNode.call(NativeCAPISymbols.FUN_PY_TRUFFLE_OBJECT_SIZE, toSulongNode.execute(self)));
+        }
     }
 
     @Builtin(name = __REPR__, minNumOfPositionalArgs = 1)
diff --git a/graalpython/lib-graalpython/python_cext.py b/graalpython/lib-graalpython/python_cext.py
@@ -724,11 +724,14 @@ def PyModule_AddObject(m, k, v):
     return None
 
 
+@may_raise
 def PyStructSequence_New(typ):
-    return typ()
+    n = len(typ._fields)
+    return typ(*([None]*n))
 
 
 namedtuple_type = None
+@may_raise
 def PyStructSequence_InitType2(type_name, type_doc, field_names, field_docs):
     assert len(field_names) == len(field_docs)
     global namedtuple_type
@@ -740,6 +743,8 @@ def PyStructSequence_InitType2(type_name, type_doc, field_names, field_docs):
         prop = getattr(new_type, field_names[i])
         assert isinstance(prop, property)
         prop.__doc__ = field_docs[i]
+    # ensure '_fields' attribute; required in 'PyStructSequence_New'
+    assert hasattr(new_type, "_fields")
     return new_type
 
 
