Update HPy inlined files: 5ebc33c

Author: fangerer

graalpython/com.oracle.graal.python.cext/include/hpy.h

@@ -123,6 +123,9 @@ typedef struct { intptr_t _i; } HPyThreadState;
 #define HPy_NULL _hconv(0)
 #define HPy_IsNull(h) ((h)._i == 0)
 
+#define HPyListBuilder_IsNull(h) ((h)._lst == 0)
+#define HPyTupleBuilder_IsNull(h) ((h)._tup == 0)
+
 #define HPyField_NULL _hfconv(0)
 #define HPyField_IsNull(f) ((f)._i == 0)
 
@@ -141,12 +144,23 @@ typedef struct _HPyContext_s HPyContext;
     typedef intptr_t HPy_ssize_t;
     typedef intptr_t HPy_hash_t;
     typedef uint32_t HPy_UCS4;
+
+    /* HPyCapsule field keys */
+    typedef enum {
+        HPyCapsule_key_Pointer = 0,
+        HPyCapsule_key_Name = 1,
+        HPyCapsule_key_Context = 2,
+        HPyCapsule_key_Destructor = 3,
+    } _HPyCapsule_key;
+
 #else
     typedef Py_ssize_t HPy_ssize_t;
     typedef Py_hash_t HPy_hash_t;
     typedef Py_UCS4 HPy_UCS4;
 #endif
 
+typedef void (*HPyCapsule_Destructor)(const char *name, void *pointer, void *context);
+
 
 /* ~~~~~~~~~~~~~~~~ Additional #includes ~~~~~~~~~~~~~~~~ */
 
@@ -159,6 +173,7 @@ typedef struct _HPyContext_s HPyContext;
 #include "hpy/runtime/argparse.h"
 #include "hpy/runtime/buildvalue.h"
 #include "hpy/runtime/helpers.h"
+#include "hpy/runtime/structseq.h"
 
 #ifdef HPY_UNIVERSAL_ABI
 #   include "hpy/universal/autogen_ctx.h"

graalpython/com.oracle.graal.python.cext/include/hpy/autogen_hpyslot.h

@@ -57,7 +57,9 @@ typedef enum {
     HPy_sq_item = 44,
     HPy_sq_length = 45,
     HPy_sq_repeat = 46,
+    HPy_tp_call = 50,
     HPy_tp_init = 60,
+    HPy_tp_iter = 62,
     HPy_tp_new = 65,
     HPy_tp_repr = 66,
     HPy_tp_richcompare = 67,
@@ -114,7 +116,9 @@ typedef enum {
 #define _HPySlot_SIG__HPy_sq_item HPyFunc_SSIZEARGFUNC
 #define _HPySlot_SIG__HPy_sq_length HPyFunc_LENFUNC
 #define _HPySlot_SIG__HPy_sq_repeat HPyFunc_SSIZEARGFUNC
+#define _HPySlot_SIG__HPy_tp_call HPyFunc_KEYWORDS
 #define _HPySlot_SIG__HPy_tp_init HPyFunc_INITPROC
+#define _HPySlot_SIG__HPy_tp_iter HPyFunc_GETITERFUNC
 #define _HPySlot_SIG__HPy_tp_new HPyFunc_KEYWORDS
 #define _HPySlot_SIG__HPy_tp_repr HPyFunc_REPRFUNC
 #define _HPySlot_SIG__HPy_tp_richcompare HPyFunc_RICHCMPFUNC

graalpython/com.oracle.graal.python.cext/include/hpy/cpython/autogen_api_impl.h

@@ -110,6 +110,11 @@ HPyAPI_FUNC HPy_ssize_t HPy_Length(HPyContext *ctx, HPy h)
     return PyObject_Length(_h2py(h));
 }
 
+HPyAPI_FUNC int HPySequence_Check(HPyContext *ctx, HPy h)
+{
+    return PySequence_Check(_h2py(h));
+}
+
 HPyAPI_FUNC int HPyNumber_Check(HPyContext *ctx, HPy h)
 {
     return PyNumber_Check(_h2py(h));
@@ -404,6 +409,19 @@ HPyAPI_FUNC HPy HPy_Type(HPyContext *ctx, HPy obj)
     return _py2h(PyObject_Type(_h2py(obj)));
 }
 
+HPyAPI_FUNC int HPy_SetType(HPyContext *ctx, HPy obj, HPy type)
+{
+        assert(PyType_Check(_h2py(type)));
+        _h2py(obj)->ob_type = (PyTypeObject*) _h2py(type);
+        return 0;
+}
+
+HPyAPI_FUNC const char *HPyType_GetName(HPyContext *ctx, HPy type)
+{
+        assert(PyType_Check(_h2py(type)));
+        return ((PyTypeObject*) _h2py(type))->tp_name;
+}
+
 HPyAPI_FUNC HPy HPy_Repr(HPyContext *ctx, HPy obj)
 {
     return _py2h(PyObject_Repr(_h2py(obj)));
@@ -439,6 +457,11 @@ HPyAPI_FUNC HPy_hash_t HPy_Hash(HPyContext *ctx, HPy obj)
     return PyObject_Hash(_h2py(obj));
 }
 
+HPyAPI_FUNC HPy HPySeqIter_New(HPyContext *ctx, HPy seq)
+{
+    return _py2h(PySeqIter_New(_h2py(seq)));
+}
+
 HPyAPI_FUNC int HPyBytes_Check(HPyContext *ctx, HPy h)
 {
     return PyBytes_Check(_h2py(h));
@@ -534,6 +557,21 @@ HPyAPI_FUNC HPy HPyUnicode_DecodeLatin1(HPyContext *ctx, const char *s, HPy_ssiz
     return _py2h(PyUnicode_DecodeLatin1(s, size, errors));
 }
 
+HPyAPI_FUNC HPy HPyUnicode_FromEncodedObject(HPyContext *ctx, HPy obj, const char *encoding, const char *errors)
+{
+    return _py2h(PyUnicode_FromEncodedObject(_h2py(obj), encoding, errors));
+}
+
+HPyAPI_FUNC HPy HPyUnicode_InternFromString(HPyContext *ctx, const char *str)
+{
+    return _py2h(PyUnicode_InternFromString(str));
+}
+
+HPyAPI_FUNC HPy HPyUnicode_Substring(HPyContext *ctx, HPy obj, HPy_ssize_t start, HPy_ssize_t end)
+{
+    return _py2h(PyUnicode_Substring(_h2py(obj), start, end));
+}
+
 HPyAPI_FUNC int HPyList_Check(HPyContext *ctx, HPy h)
 {
     return PyList_Check(_h2py(h));
@@ -559,16 +597,41 @@ HPyAPI_FUNC HPy HPyDict_New(HPyContext *ctx)
     return _py2h(PyDict_New());
 }
 
+HPyAPI_FUNC HPy HPyDict_Keys(HPyContext *ctx, HPy h)
+{
+    return _py2h(PyDict_Keys(_h2py(h)));
+}
+
 HPyAPI_FUNC int HPyTuple_Check(HPyContext *ctx, HPy h)
 {
     return PyTuple_Check(_h2py(h));
 }
 
+HPyAPI_FUNC int HPySlice_Unpack(HPyContext *ctx, HPy slice, HPy_ssize_t *start, HPy_ssize_t *stop, HPy_ssize_t *step)
+{
+    return PySlice_Unpack(_h2py(slice), start, stop, step);
+}
+
+HPyAPI_FUNC HPy HPyContextVar_New(HPyContext *ctx, const char *name, HPy default_value)
+{
+    return _py2h(PyContextVar_New(name, _h2py(default_value)));
+}
+
+HPyAPI_FUNC HPy HPyContextVar_Set(HPyContext *ctx, HPy context_var, HPy value)
+{
+    return _py2h(PyContextVar_Set(_h2py(context_var), _h2py(value)));
+}
+
 HPyAPI_FUNC HPy HPyImport_ImportModule(HPyContext *ctx, const char *name)
 {
     return _py2h(PyImport_ImportModule(name));
 }
 
+HPyAPI_FUNC int HPyCapsule_IsValid(HPyContext *ctx, HPy capsule, const char *name)
+{
+    return PyCapsule_IsValid(_h2py(capsule), name);
+}
+
 HPyAPI_FUNC void HPy_ReenterPythonExecution(HPyContext *ctx, HPyThreadState state)
 {
     PyEval_RestoreThread(_h2threads(state));
@@ -579,3 +642,32 @@ HPyAPI_FUNC HPyThreadState HPy_LeavePythonExecution(HPyContext *ctx)
     return _threads2h(PyEval_SaveThread());
 }
 
+HPyAPI_FUNC int HPyType_CheckSlot(HPyContext *ctx, HPy type, HPyDef *value)
+{
+            PyObject *result = _h2py(type);
+            struct _typeobject* t = ((struct _typeobject*) result);
+            char msg[256];
+            switch (value->slot.slot) {
+                case HPy_nb_inplace_add:
+                    return t->tp_as_number != NULL && t->tp_as_number->nb_inplace_add == value->slot.cpy_trampoline;
+                case HPy_nb_power:
+                    // TODO: this needs proper cast for C++
+                    return t->tp_as_number != NULL && (void*) t->tp_as_number->nb_power == (void*) value->slot.cpy_trampoline;
+                case HPy_nb_subtract:
+                    return t->tp_as_number != NULL && (void*) t->tp_as_number->nb_subtract == (void*) value->slot.cpy_trampoline;
+                case HPy_nb_true_divide:
+                    return t->tp_as_number != NULL && (void*) t->tp_as_number->nb_true_divide == (void*) value->slot.cpy_trampoline;
+                case HPy_nb_add:
+                    return t->tp_as_number != NULL && (void*) t->tp_as_number->nb_add == (void*) value->slot.cpy_trampoline;
+                case HPy_nb_and:
+                    return t->tp_as_number != NULL && (void*) t->tp_as_number->nb_and == (void*) value->slot.cpy_trampoline;
+                case HPy_nb_or:
+                    return t->tp_as_number != NULL && (void*) t->tp_as_number->nb_or == (void*) value->slot.cpy_trampoline;
+                case HPy_nb_xor:
+                    return t->tp_as_number != NULL && (void*) t->tp_as_number->nb_xor == (void*) value->slot.cpy_trampoline;
+                default:
+                    snprintf(msg, 256, "Unsupported slot in HPyTypeSlot_Is: %d", value->slot.slot);
+                    Py_FatalError(msg);
+            }
+}
+

graalpython/com.oracle.graal.python.cext/include/hpy/cpython/misc.h

@@ -126,9 +126,14 @@ struct _HPyContext_s {
     HPy h_BoolType;
     HPy h_LongType;
     HPy h_FloatType;
+    HPy h_ComplexType;
     HPy h_UnicodeType;
+    HPy h_BytesType;
     HPy h_TupleType;
     HPy h_ListType;
+    HPy h_MemoryViewType;
+    HPy h_CapsuleType;
+    HPy h_SliceType;
 };
 
 /* XXX! should be defined only once, not once for every .c! */
@@ -216,9 +221,14 @@ HPyAPI_FUNC HPyContext * _HPyGetContext(void) {
         ctx->h_BoolType = _py2h((PyObject *)&PyBool_Type);
         ctx->h_LongType = _py2h((PyObject *)&PyLong_Type);
         ctx->h_FloatType = _py2h((PyObject *)&PyFloat_Type);
+        ctx->h_ComplexType = _py2h((PyObject *)&PyComplex_Type);
         ctx->h_UnicodeType = _py2h((PyObject *)&PyUnicode_Type);
+        ctx->h_BytesType = _py2h((PyObject *)&PyBytes_Type);
         ctx->h_TupleType = _py2h((PyObject *)&PyTuple_Type);
         ctx->h_ListType = _py2h((PyObject *)&PyList_Type);
+        ctx->h_MemoryViewType = _py2h((PyObject *)&PyMemoryView_Type);
+        ctx->h_CapsuleType = _py2h((PyObject *)&PyCapsule_Type);
+        ctx->h_SliceType = _py2h((PyObject *)&PySlice_Type);
     }
     return ctx;
 }
@@ -329,6 +339,11 @@ HPyAPI_FUNC int HPy_TypeCheck(HPyContext *ctx, HPy h_obj, HPy h_type)
     return ctx_TypeCheck(ctx, h_obj, h_type);
 }
 
+HPyAPI_FUNC int HPyType_IsSubtype(HPyContext *ctx, HPy h_sub, HPy h_type)
+{
+    return ctx_Type_IsSubtype(ctx, h_sub, h_type);
+}
+
 HPyAPI_FUNC int HPy_Is(HPyContext *ctx, HPy h_obj, HPy h_other)
 {
     return ctx_Is(ctx, h_obj, h_other);
@@ -425,4 +440,73 @@ HPyAPI_FUNC int HPyErr_Occurred(HPyContext *ctx) {
     return ctx_Err_Occurred(ctx);
 }
 
+HPyAPI_FUNC int HPyContextVar_Get(HPyContext *ctx, HPy context_var, HPy default_value, HPy *result) {
+    PyObject *py_result;
+    int ret = PyContextVar_Get(_h2py(context_var), _h2py(default_value), &py_result);
+    *result = _py2h(py_result);
+    return ret;
+}
+
+HPyAPI_FUNC HPy HPyCapsule_New(HPyContext *ctx, void *pointer, const char *name, HPyCapsule_Destructor destructor)
+{
+    return ctx_Capsule_New(ctx, pointer, name, destructor);
+}
+
+HPyAPI_FUNC void * HPyCapsule_GetPointer(HPyContext *ctx, HPy capsule, const char *name)
+{
+    return PyCapsule_GetPointer(_h2py(capsule), name);
+}
+
+HPyAPI_FUNC const char * HPyCapsule_GetName(HPyContext *ctx, HPy capsule)
+{
+    return PyCapsule_GetName(_h2py(capsule));
+}
+
+HPyAPI_FUNC void * HPyCapsule_GetContext(HPyContext *ctx, HPy capsule)
+{
+    return PyCapsule_GetContext(_h2py(capsule));
+}
+
+HPyAPI_FUNC HPyCapsule_Destructor HPyCapsule_GetDestructor(HPyContext *ctx, HPy capsule)
+{
+    return ctx_Capsule_GetDestructor(ctx, capsule);
+}
+
+HPyAPI_FUNC int HPyCapsule_SetPointer(HPyContext *ctx, HPy capsule, void *pointer)
+{
+    return PyCapsule_SetPointer(_h2py(capsule), pointer);
+}
+
+HPyAPI_FUNC int HPyCapsule_SetName(HPyContext *ctx, HPy capsule, const char *name)
+{
+    return PyCapsule_SetName(_h2py(capsule), name);
+}
+
+HPyAPI_FUNC int HPyCapsule_SetContext(HPyContext *ctx, HPy capsule, void *context)
+{
+    return PyCapsule_SetContext(_h2py(capsule), context);
+}
+
+HPyAPI_FUNC int HPyCapsule_SetDestructor(HPyContext *ctx, HPy capsule, HPyCapsule_Destructor destructor)
+{
+    return ctx_Capsule_SetDestructor(ctx, capsule, destructor);
+}
+
+HPyAPI_FUNC HPy HPy_MaybeGetAttr_s(HPyContext *ctx, HPy obj, const char *name) {
+    PyObject *pyobj = _h2py(obj);
+    struct _typeobject* t = Py_TYPE(pyobj);
+    if (t->tp_getattr == NULL && t->tp_getattro == NULL) {
+        return HPy_NULL;
+    }
+    PyObject *res = PyObject_GetAttrString(pyobj, name);
+    if (res == NULL && PyErr_Occurred()) {
+        PyErr_Clear();
+    }
+    return _py2h(res);
+}
+
+HPyAPI_FUNC HPy HPyDict_GetItem(HPyContext *ctx, HPy op, HPy key) {
+    return ctx_Dict_GetItem(ctx, op, key);
+}
+
 #endif /* !HPY_CPYTHON_MISC_H */

graalpython/com.oracle.graal.python.cext/include/hpy/hpytype.h

@@ -46,7 +46,7 @@ typedef struct {
 typedef enum {
     HPyType_SpecParam_Base = 1,
     HPyType_SpecParam_BasesTuple = 2,
-    //HPyType_SpecParam_Metaclass = 3,
+    HPyType_SpecParam_Metaclass = 3,
     //HPyType_SpecParam_Module = 4,
 } HPyType_SpecParam_Kind;
 

graalpython/com.oracle.graal.python.cext/include/hpy/inline_helpers.h

@@ -1,6 +1,7 @@
 #ifndef HPY_INLINE_HELPERS_H
 #define HPY_INLINE_HELPERS_H
 
+#include <assert.h>
 #if defined(_MSC_VER)
 # include <malloc.h>  /* for alloca() */
 #endif
@@ -15,6 +16,45 @@ HPyAPI_FUNC HPy HPyErr_SetFromErrnoWithFilenameObject(HPyContext *ctx, HPy h_typ
     return HPyErr_SetFromErrnoWithFilenameObjects(ctx, h_type, filename, HPy_NULL);
 }
 
+HPyAPI_FUNC int HPySlice_AdjustIndices(HPy_ssize_t length, HPy_ssize_t *start, HPy_ssize_t *stop, HPy_ssize_t step) {
+    /* Taken from CPython: Written by Jim Hugunin and Chris Chase. */
+    /* this is harder to get right than you might think */
+    assert(step != 0);
+    // assert(step >= -PY_SSIZE_T_MAX); TODO: add the macro for HPy_ssize_t
+
+    if (*start < 0) {
+        *start += length;
+        if (*start < 0) {
+            *start = (step < 0) ? -1 : 0;
+        }
+    }
+    else if (*start >= length) {
+        *start = (step < 0) ? length - 1 : length;
+    }
+
+    if (*stop < 0) {
+        *stop += length;
+        if (*stop < 0) {
+            *stop = (step < 0) ? -1 : 0;
+        }
+    }
+    else if (*stop >= length) {
+        *stop = (step < 0) ? length - 1 : length;
+    }
+
+    if (step < 0) {
+        if (*stop < *start) {
+            return (*start - *stop - 1) / (-step) + 1;
+        }
+    }
+    else {
+        if (*start < *stop) {
+            return (*stop - *start - 1) / step + 1;
+        }
+    }
+    return 0;
+}
+
 HPyAPI_FUNC HPy HPyTuple_Pack(HPyContext *ctx, HPy_ssize_t n, ...) {
     va_list vargs;
     HPy_ssize_t i;