[GR-12969] Implement PyStructSequence_* C API functions.

PullRequest: graalpython/574

Author: fangerer

graalpython/com.oracle.graal.python.cext/src/capi.c

@@ -85,10 +85,14 @@ void initialize_type_structure(PyTypeObject* structure, PyTypeObject* ptype, pol
 
     unsigned long original_flags = structure->tp_flags;
     Py_ssize_t basicsize = structure->tp_basicsize;
+    allocfunc alloc = structure->tp_alloc;
     PyTypeObject* type_handle = truffle_assign_managed(structure, ptype);
     // write flags as specified in the dummy to the PythonClass object
     type_handle->tp_flags = original_flags | Py_TPFLAGS_READY;
     type_handle->tp_basicsize = basicsize;
+    if (alloc) {
+    	type_handle->tp_alloc = alloc;
+    }
 }
 
 static void initialize_builtin_type(PyTypeObject* structure, const char* typname, polyglot_typeid tid) {
@@ -303,6 +307,11 @@ Py_ssize_t get_tp_basicsize(PyTypeObject* obj) {
 	return obj->tp_basicsize;
 }
 
+/** to be used from Java code only; reads native 'tp_alloc' field */
+allocfunc get_tp_alloc(PyTypeObject* obj) {
+	return obj->tp_alloc;
+}
+
 /** to be used from Java code only; returns the type ID for a byte array */
 polyglot_typeid get_byte_array_typeid(uint64_t len) {
     return polyglot_array_typeid(polyglot_i8_typeid(), len);
@@ -397,6 +406,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) {

graalpython/com.oracle.graal.python.cext/src/capi.h

@@ -263,7 +263,7 @@ void* wrap_unsupported(void *fun, ...);
            wrap_direct :                                                                 \
            wrap_unsupported))))))))
 
-#define PY_TRUFFLE_TYPE(__TYPE_NAME__, __SUPER_TYPE__, __FLAGS__, __SIZE__) {\
+#define PY_TRUFFLE_TYPE_WITH_ALLOC(__TYPE_NAME__, __SUPER_TYPE__, __FLAGS__, __SIZE__, __ALLOC__) {\
     PyVarObject_HEAD_INIT((__SUPER_TYPE__), 0)\
     __TYPE_NAME__,                              /* tp_name */\
     (__SIZE__),                                 /* tp_basicsize */\
@@ -300,12 +300,14 @@ void* wrap_unsupported(void *fun, ...);
     0,                                          /* tp_descr_set */\
     0,                                          /* tp_dictoffset */\
     0,                                          /* tp_init */\
-    0,                                          /* tp_alloc */\
+    (__ALLOC__),                                /* tp_alloc */\
     0,                                          /* tp_new */\
     0,                                          /* tp_free */\
     0,                                          /* tp_is_gc */\
 }
 
+#define PY_TRUFFLE_TYPE(__TYPE_NAME__, __SUPER_TYPE__, __FLAGS__, __SIZE__) PY_TRUFFLE_TYPE_WITH_ALLOC(__TYPE_NAME__, __SUPER_TYPE__, __FLAGS__, __SIZE__, 0)
+
 /** to be used from Java code only; returns a type's basic size */
 #define BASICSIZE_GETTER(__typename__)extern Py_ssize_t get_ ## __typename__ ## _basicsize() { \
 	return sizeof(__typename__); \

graalpython/com.oracle.graal.python.cext/src/structseq.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2019, 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
@@ -40,8 +40,92 @@
  */
 #include "capi.h"
 
-/* StructSequences */
+/* StructSequences a.k.a. 'namedtuple' */
 UPCALL_ID(PyStructSequence_New);
 PyObject* PyStructSequence_New(PyTypeObject* o) {
-    return UPCALL_CEXT_O(_jls_PyStructSequence_New, native_to_java((PyObject*)o));
+    return UPCALL_CEXT_O(_jls_PyStructSequence_New, native_type_to_java(o));
 }
+
+UPCALL_ID(PyStructSequence_InitType2);
+int PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc) {
+    Py_ssize_t n_members = desc->n_in_sequence;
+    Py_ssize_t i;
+
+    memset(type, 0, sizeof(PyTypeObject));
+
+    // 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));
+
+    // copy generic fields (CPython mem-copies a template)
+    type->tp_basicsize = sizeof(PyStructSequence) - sizeof(PyObject *);
+    type->tp_itemsize = sizeof(PyObject *);
+    type->tp_repr = newType->tp_repr;
+    type->tp_flags = Py_TPFLAGS_DEFAULT;
+    type->tp_members = NULL;
+    type->tp_new = newType->tp_new;
+    type->tp_base = &PyTuple_Type;
+    type->tp_alloc = newType->tp_alloc;
+
+    // now copy specific fields
+    type->tp_name = newType->tp_name;
+    type->tp_doc = newType->tp_doc;
+    type->tp_dict = newType->tp_dict;
+
+    // now initialize the type
+    if (PyType_Ready(type) < 0)
+        return -1;
+    Py_INCREF(type);
+
+    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);
+}
+

graalpython/com.oracle.graal.python.cext/src/tupleobject.c

@@ -40,7 +40,11 @@
  */
 #include "capi.h"
 
-PyTypeObject PyTuple_Type = PY_TRUFFLE_TYPE("tuple", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS, sizeof(PyTupleObject) - sizeof(PyObject *));
+/* prototype */
+PyObject* PyTruffle_Tuple_Alloc(PyTypeObject* cls, Py_ssize_t nitems);
+
+/* tuple type */
+PyTypeObject PyTuple_Type = PY_TRUFFLE_TYPE_WITH_ALLOC("tuple", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS, sizeof(PyTupleObject) - sizeof(PyObject *), PyTruffle_Tuple_Alloc);
 
 /* Tuples */
 UPCALL_ID(PyTuple_New);
@@ -79,3 +83,70 @@ PyObject* PyTuple_Pack(Py_ssize_t n, ...) {
     }
     return result;
 }
+
+MUST_INLINE
+static PyObject * tuple_create(PyObject *iterable) {
+    if (iterable == NULL) {
+        return PyTuple_New(0);
+    }
+    return PySequence_Tuple(iterable);
+}
+
+POLYGLOT_DECLARE_TYPE(PyTupleObject);
+PyObject * tuple_subtype_new(PyTypeObject *type, PyObject *iterable) {
+	PyTupleObject* newobj;
+    PyObject *tmp, *item;
+    Py_ssize_t i, n;
+
+    assert(PyType_IsSubtype(type, &PyTuple_Type));
+    tmp = tuple_create(iterable);
+    if (tmp == NULL) {
+        return NULL;
+    }
+    assert(PyTuple_Check(tmp));
+    n = PyTuple_GET_SIZE(tmp);
+
+    newobj = (PyTupleObject*) type->tp_alloc(type, n);
+    if (newobj == NULL) {
+        return NULL;
+    }
+    newobj->ob_item = (PyObject **) ((char *)newobj + offsetof(PyTupleObject, ob_item) + sizeof(PyObject **));
+    newobj = polyglot_from_PyTupleObject(newobj);
+    for (i = 0; i < n; i++) {
+        item = PyTuple_GetItem(tmp, i);
+        Py_INCREF(item);
+        PyTuple_SetItem((PyObject*)newobj, i, item);
+    }
+    Py_DECREF(tmp);
+
+    // 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;
+}
+
+PyObject* PyTruffle_Tuple_Alloc(PyTypeObject* cls, Py_ssize_t nitems) {
+	/*
+	 * TODO(fa): For 'PyVarObjects' (i.e. 'nitems > 0') we increase the size by 'sizeof(void *)'
+	 * because this additional pointer can then be used as pointer to the element array.
+	 * CPython usually embeds the array in the struct but Sulong doesn't currently support that.
+	 * So we allocate space for the additional array pointer.
+	 * Also consider any 'PyVarObject' (in particular 'PyTupleObject') if this is fixed.
+	 */
+	Py_ssize_t size = cls->tp_basicsize + cls->tp_itemsize * nitems + sizeof(PyObject **);
+    PyObject* newObj = (PyObject*)PyObject_Malloc(size);
+    if(cls->tp_dictoffset) {
+    	*((PyObject **) ((char *)newObj + cls->tp_dictoffset)) = NULL;
+    }
+    Py_TYPE(newObj) = cls;
+    if (nitems > 0) {
+        ((PyVarObject*)newObj)->ob_size = nitems;
+    }
+    return newObj;
+}
+