[GR-45273] Additional C API functions in preparation of sqlite.

PullRequest: graalpython/2707

Author: lukasstadler

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

@@ -0,0 +1,28 @@
+/* Copyright (c) 2023, Oracle and/or its affiliates.
+ * Copyright (C) 1996-2022 Python Software Foundation
+ *
+ * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+ */
+#ifndef Py_STRCMP_H
+#define Py_STRCMP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(int) PyOS_mystrnicmp(const char *, const char *, Py_ssize_t);
+PyAPI_FUNC(int) PyOS_mystricmp(const char *, const char *);
+
+#ifdef MS_WINDOWS
+#define PyOS_strnicmp strnicmp
+#define PyOS_stricmp stricmp
+#else
+#define PyOS_strnicmp PyOS_mystrnicmp
+#define PyOS_stricmp PyOS_mystricmp
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_STRCMP_H */

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

@@ -2041,6 +2041,10 @@ PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock a, int b) {
 PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock() {
     return GraalPyThread_allocate_lock();
 }
+#undef PyThread_get_thread_ident
+PyAPI_FUNC(unsigned long) PyThread_get_thread_ident() {
+    return GraalPyThread_get_thread_ident();
+}
 #undef PyThread_release_lock
 PyAPI_FUNC(void) PyThread_release_lock(PyThread_type_lock a) {
     GraalPyThread_release_lock(a);

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

@@ -268,6 +268,7 @@ typedef struct {
     BUILTIN(PyThreadState_GetDict, PyObject*) \
     BUILTIN(PyThread_acquire_lock, int, PyThread_type_lock, int) \
     BUILTIN(PyThread_allocate_lock, PyThread_type_lock) \
+    BUILTIN(PyThread_get_thread_ident, unsigned long) \
     BUILTIN(PyThread_release_lock, void, PyThread_type_lock) \
     BUILTIN(PyTraceBack_Here, int, PyFrameObject*) \
     BUILTIN(PyTraceMalloc_Track, int, unsigned int, uintptr_t, size_t) \

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

@@ -0,0 +1,13 @@
+/* Copyright (c) 2023, Oracle and/or its affiliates.
+ * Copyright (C) 1996-2022 Python Software Foundation
+ *
+ * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+ */
+
+#include "capi.h"
+
+int
+PyDescr_IsData(PyObject *ob)
+{
+    return Py_TYPE(ob)->tp_descr_set != NULL;
+}

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

@@ -125,39 +125,15 @@ int PyObject_GenericInit(PyObject* self, PyObject* args, PyObject* kwds) {
     return self;
 }
 
-#define IS_SINGLE_ARG(_fmt) ((_fmt[0]) != '\0' && (_fmt[1]) == '\0')
-
-PyObject* PyObject_Call(PyObject* callable, PyObject* args, PyObject* kwargs) {
-	return Graal_PyTruffleObject_Call1(callable, args, kwargs, 0);
-}
-
-PyObject* PyObject_CallObject(PyObject* callable, PyObject* args) {
-	return Graal_PyTruffleObject_Call1(callable, args, NULL, 0);
-}
-
-PyObject* PyObject_CallFunction(PyObject* callable, const char* fmt, ...) {
-    if (fmt == NULL || fmt[0] == '\0') {
-	    return Graal_PyTruffleObject_Call1(callable, NULL, NULL, 0);
-    }
-    va_list va;
-    va_start(va, fmt);
-    PyObject* args = Py_VaBuildValue(fmt, va);
-    va_end(va);
-	return Graal_PyTruffleObject_Call1(callable, args, NULL, IS_SINGLE_ARG(fmt));
-}
-
-PyObject* _PyObject_CallFunction_SizeT(PyObject* callable, const char* fmt, ...) {
-    if (fmt == NULL || fmt[0] == '\0') {
-	    return Graal_PyTruffleObject_Call1(callable, NULL, NULL, 0);
-    }
-    va_list va;
-    va_start(va, fmt);
-    PyObject* args = Py_VaBuildValue(fmt, va);
-    va_end(va);
-	return Graal_PyTruffleObject_Call1(callable, args, NULL, IS_SINGLE_ARG(fmt));
+PyObject * _PyObject_CallMethodIdObjArgs(PyObject *callable, struct _Py_Identifier *name, ...) {
+    va_list vargs;
+    va_start(vargs, name);
+    // the arguments are given as a variable list followed by NULL
+    PyObject *result = GraalPyTruffleObject_CallMethodObjArgs(callable, _PyUnicode_FromId(name), &vargs);
+    va_end(vargs);
+    return result;
 }
 
-typedef PyObject *(*call_fun_obj_args_t)(PyObject *, void *);
 PyObject* PyObject_CallFunctionObjArgs(PyObject *callable, ...) {
     va_list vargs;
     va_start(vargs, callable);
@@ -167,20 +143,6 @@ PyObject* PyObject_CallFunctionObjArgs(PyObject *callable, ...) {
     return result;
 }
 
-typedef PyObject *(*call_method_t)(PyObject *, void *, void *, int32_t);
-PyObject* PyObject_CallMethod(PyObject* object, const char* method, const char* fmt, ...) {
-    PyObject* args;
-    if (fmt == NULL || fmt[0] == '\0') {
-        return Graal_PyTruffleObject_CallMethod1(object, truffleString(method), NULL, 0);
-    }
-    va_list va;
-    va_start(va, fmt);
-    args = Py_VaBuildValue(fmt, va);
-    va_end(va);
-    return Graal_PyTruffleObject_CallMethod1(object, truffleString(method), args, IS_SINGLE_ARG(fmt));
-}
-
-typedef PyObject *(*call_meth_obj_args_t)(PyObject *, void *, void *);
 PyObject* PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...) {
     va_list vargs;
     va_start(vargs, name);
@@ -190,18 +152,6 @@ PyObject* PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...) {
     return result;
 }
 
-PyObject* _PyObject_CallMethod_SizeT(PyObject* object, const char* method, const char* fmt, ...) {
-    PyObject* args;
-    if (fmt == NULL || fmt[0] == '\0') {
-        return Graal_PyTruffleObject_CallMethod1(object, truffleString(method), NULL, 0);
-    }
-    va_list va;
-    va_start(va, fmt);
-    args = Py_VaBuildValue(fmt, va);
-    va_end(va);
-    return Graal_PyTruffleObject_CallMethod1(object, truffleString(method), args, IS_SINGLE_ARG(fmt));
-}
-
 PyObject* _PyObject_MakeTpCall(PyThreadState *tstate, PyObject *callable,
                      PyObject *const *args, Py_ssize_t nargs,
                      PyObject *keywords) {
@@ -345,6 +295,98 @@ PyObject* PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *kwarg
     return result;
 }
 
+
+// Taken from cpython object.c
+/* Specialized version of _PyObject_GenericGetAttrWithDict
+   specifically for the LOAD_METHOD opcode.
+
+   Return 1 if a method is found, 0 if it's a regular attribute
+   from __dict__ or something returned by using a descriptor
+   protocol.
+
+   `method` will point to the resolved attribute or NULL.  In the
+   latter case, an error will be set.
+*/
+int
+_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method)
+{
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    PyObject *attr;
+    int meth_found = 0;
+
+    assert(*method == NULL);
+
+    if (Py_TYPE(obj)->tp_getattro != PyObject_GenericGetAttr
+            || !PyUnicode_Check(name)) {
+        *method = PyObject_GetAttr(obj, name);
+        return 0;
+    }
+
+    if (tp->tp_dict == NULL && PyType_Ready(tp) < 0)
+        return 0;
+
+    descr = _PyType_Lookup(tp, name);
+    if (descr != NULL) {
+        Py_INCREF(descr);
+        if (_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                *method = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                return 0;
+            }
+        }
+    }
+
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = PyDict_GetItemWithError(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            *method = attr;
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            return 0;
+        }
+        else {
+            Py_DECREF(dict);
+            if (PyErr_Occurred()) {
+                Py_XDECREF(descr);
+                return 0;
+            }
+        }
+    }
+
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+
+    if (f != NULL) {
+        *method = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        return 0;
+    }
+
+    if (descr != NULL) {
+        *method = descr;
+        return 0;
+    }
+
+    PyErr_Format(PyExc_AttributeError,
+                 "'%.50s' object has no attribute '%U'",
+                 tp->tp_name, name);
+
+//    set_attribute_error_context(obj, name);
+    return 0;
+}
+
 // Taken from cpython call.c
 PyObject* PyObject_VectorcallDict(PyObject *callable, PyObject *const *args,
                        size_t nargsf, PyObject *kwargs) {
@@ -380,6 +422,41 @@ PyObject* PyObject_VectorcallDict(PyObject *callable, PyObject *const *args,
     return res;
 }
 
+// Taken from cpython call.c
+PyObject *
+PyObject_VectorcallMethod(PyObject *name, PyObject *const *args,
+                           size_t nargsf, PyObject *kwnames)
+{
+    assert(name != NULL);
+    assert(args != NULL);
+    assert(PyVectorcall_NARGS(nargsf) >= 1);
+
+    PyThreadState *tstate = _PyThreadState_GET();
+    PyObject *callable = NULL;
+    /* Use args[0] as "self" argument */
+    int unbound = _PyObject_GetMethod(args[0], name, &callable);
+    if (callable == NULL) {
+        return NULL;
+    }
+
+    if (unbound) {
+        /* We must remove PY_VECTORCALL_ARGUMENTS_OFFSET since
+         * that would be interpreted as allowing to change args[-1] */
+        nargsf &= ~PY_VECTORCALL_ARGUMENTS_OFFSET;
+    }
+    else {
+        /* Skip "self". We can keep PY_VECTORCALL_ARGUMENTS_OFFSET since
+         * args[-1] in the onward call is args[0] here. */
+        args++;
+        nargsf--;
+    }
+    PyObject *result = _PyObject_VectorcallTstate(tstate, callable,
+                                                  args, nargsf, kwnames);
+    Py_DECREF(callable);
+    return result;
+}
+
+
 // Taken from CPython object.c
 int
 PyObject_GenericSetDict(PyObject *obj, PyObject *value, void *context)

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

@@ -205,3 +205,66 @@ void PyObject_GC_Del(void *tp) {
 	PyObject_Free(tp);
 }
 
+#define IS_SINGLE_ARG(_fmt) ((_fmt[0]) != '\0' && (_fmt[1]) == '\0')
+
+PyObject* PyObject_Call(PyObject* callable, PyObject* args, PyObject* kwargs) {
+	return Graal_PyTruffleObject_Call1(callable, args, kwargs, 0);
+}
+
+PyObject* PyObject_CallObject(PyObject* callable, PyObject* args) {
+	return Graal_PyTruffleObject_Call1(callable, args, NULL, 0);
+}
+
+PyObject* PyObject_CallFunction(PyObject* callable, const char* fmt, ...) {
+    if (fmt == NULL || fmt[0] == '\0') {
+	    return Graal_PyTruffleObject_Call1(callable, NULL, NULL, 0);
+    }
+    va_list va;
+    va_start(va, fmt);
+    PyObject* args = Py_VaBuildValue(fmt, va);
+    va_end(va);
+    // A special case in CPython for backwards compatibility
+    if (IS_SINGLE_ARG(fmt) && PyTuple_Check(args)) {
+    	return Graal_PyTruffleObject_Call1(callable, args, NULL, 0);
+    }
+	return Graal_PyTruffleObject_Call1(callable, args, NULL, IS_SINGLE_ARG(fmt));
+}
+
+PyObject* _PyObject_CallFunction_SizeT(PyObject* callable, const char* fmt, ...) {
+    if (fmt == NULL || fmt[0] == '\0') {
+	    return Graal_PyTruffleObject_Call1(callable, NULL, NULL, 0);
+    }
+    va_list va;
+    va_start(va, fmt);
+    PyObject* args = Py_VaBuildValue(fmt, va);
+    va_end(va);
+    // A special case in CPython for backwards compatibility
+    if (IS_SINGLE_ARG(fmt) && PyTuple_Check(args)) {
+    	return Graal_PyTruffleObject_Call1(callable, args, NULL, 0);
+    }
+	return Graal_PyTruffleObject_Call1(callable, args, NULL, IS_SINGLE_ARG(fmt));
+}
+
+PyObject* PyObject_CallMethod(PyObject* object, const char* method, const char* fmt, ...) {
+    PyObject* args;
+    if (fmt == NULL || fmt[0] == '\0') {
+        return Graal_PyTruffleObject_CallMethod1(object, truffleString(method), NULL, 0);
+    }
+    va_list va;
+    va_start(va, fmt);
+    args = Py_VaBuildValue(fmt, va);
+    va_end(va);
+    return Graal_PyTruffleObject_CallMethod1(object, truffleString(method), args, IS_SINGLE_ARG(fmt));
+}
+
+PyObject* _PyObject_CallMethod_SizeT(PyObject* object, const char* method, const char* fmt, ...) {
+    PyObject* args;
+    if (fmt == NULL || fmt[0] == '\0') {
+        return Graal_PyTruffleObject_CallMethod1(object, truffleString(method), NULL, 0);
+    }
+    va_list va;
+    va_start(va, fmt);
+    args = Py_VaBuildValue(fmt, va);
+    va_end(va);
+    return Graal_PyTruffleObject_CallMethod1(object, truffleString(method), args, IS_SINGLE_ARG(fmt));
+}

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

@@ -0,0 +1,35 @@
+/* Copyright (c) 2023, Oracle and/or its affiliates.
+ * Copyright (C) 1996-2022 Python Software Foundation
+ *
+ * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+ */
+/* Cross platform case insensitive string compare functions
+ */
+
+#include "Python.h"
+
+int
+PyOS_mystrnicmp(const char *s1, const char *s2, Py_ssize_t size)
+{
+    const unsigned char *p1, *p2;
+    if (size == 0)
+        return 0;
+    p1 = (const unsigned char *)s1;
+    p2 = (const unsigned char *)s2;
+    for (; (--size > 0) && *p1 && *p2 && (tolower(*p1) == tolower(*p2));
+         p1++, p2++) {
+        ;
+    }
+    return tolower(*p1) - tolower(*p2);
+}
+
+int
+PyOS_mystricmp(const char *s1, const char *s2)
+{
+    const unsigned char *p1 = (const unsigned char *)s1;
+    const unsigned char *p2 = (const unsigned char *)s2;
+    for (; *p1 && *p2 && (tolower(*p1) == tolower(*p2)); p1++, p2++) {
+        ;
+    }
+    return (tolower(*p1) - tolower(*p2));
+}