Merge branch 'master' into bugfix/GR-10511

Author: ppisl

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

@@ -107,11 +107,11 @@
 #include "pyfpe.h"
 #include "memoryobject.h"
 
-#undef Py_NoValue
-#define Py_NoValue truffle_invoke(PY_TRUFFLE_CEXT, "Py_NoValue")
+#define PY_TRUFFLE_CEXT ((void*)polyglot_import("python_cext"))
+#define PY_BUILTIN ((void*)polyglot_import("python_builtins"))
 
-#define PY_TRUFFLE_CEXT ((void*)truffle_import_cached("python_cext"))
-#define PY_BUILTIN ((void*)truffle_import_cached("python_builtins"))
+#undef Py_NoValue
+#define Py_NoValue UPCALL_CEXT_O("Py_NoValue")
 
 // TODO: we must extend the refcounting behavior to support handles to managed objects
 #undef Py_DECREF

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

@@ -39,20 +39,18 @@
 #include "capi.h"
 
 // partially taken from CPython "Python/_warnings.c"
-static int warn_unicode(PyObject *category, PyObject *message, Py_ssize_t stack_level, PyObject *source) {
+MUST_INLINE static int warn_unicode(PyObject *category, PyObject *message, Py_ssize_t stack_level, PyObject *source) {
     PyObject *res;
 
     if (category == NULL) {
         category = PyExc_RuntimeWarning;
     }
 
-    PyObject *result = truffle_invoke(PY_TRUFFLE_CEXT, "_PyErr_Warn", to_java(message), to_java(category), stack_level, to_java(source));
-    if(result == ERROR_MARKER) {
+    PyObject* result = UPCALL_CEXT_O("_PyErr_Warn", native_to_java(message), native_to_java(category), stack_level, native_to_java(source));
+    if(result == NULL) {
     	return -1;
     }
-    res = to_sulong(result);
-    Py_DECREF(res);
-
+    Py_DECREF(result);
     return 0;
 }
 

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

@@ -54,27 +54,19 @@ static PyObject* null_error(void) {
 }
 
 int PyNumber_Check(PyObject *o) {
-    PyObject *result = to_sulong(truffle_invoke(PY_TRUFFLE_CEXT, "PyNumber_Check", to_java(o)));
+    PyObject *result = UPCALL_CEXT_O("PyNumber_Check", native_to_java(o));
     if(result == Py_True) {
     	return 1;
     }
     return 0;
 }
 
 static PyObject * do_unaryop(PyObject *v, UnaryOp unaryop, char *unaryop_name) {
-    PyObject *result = truffle_invoke(PY_TRUFFLE_CEXT, "PyNumber_UnaryOp", to_java(v), unaryop, truffle_read_string(unaryop_name));
-    if (result == ERROR_MARKER) {
-    	return NULL;
-    }
-    return to_sulong(result);
+    return UPCALL_CEXT_O("PyNumber_UnaryOp", native_to_java(v), unaryop, polyglot_from_string(unaryop_name, SRC_CS));
 }
 
 static PyObject * do_binop(PyObject *v, PyObject *w, BinOp binop, char *binop_name) {
-    PyObject *result = truffle_invoke(PY_TRUFFLE_CEXT, "PyNumber_BinOp", to_java(v), to_java(w), binop, truffle_read_string(binop_name));
-    if (result == ERROR_MARKER) {
-    	return NULL;
-    }
-    return to_sulong(result);
+    return UPCALL_CEXT_O("PyNumber_BinOp", native_to_java(v), native_to_java(w), binop, polyglot_from_string(binop_name, SRC_CS));
 }
 
 PyObject * PyNumber_Add(PyObject *o1, PyObject *o2) {
@@ -137,11 +129,7 @@ PyObject * PyNumber_Index(PyObject *o) {
     if (o == NULL) {
         return null_error();
     }
-    PyObject *result = truffle_invoke(PY_TRUFFLE_CEXT, "PyNumber_Index", to_java(o));
-    if (result == ERROR_MARKER) {
-    	return NULL;
-    }
-    return to_sulong(result);
+    return UPCALL_CEXT_O("PyNumber_Index", native_to_java(o));
 }
 
 Py_ssize_t PyNumber_AsSsize_t(PyObject *item, PyObject *err) {
@@ -179,66 +167,43 @@ Py_ssize_t PyNumber_AsSsize_t(PyObject *item, PyObject *err) {
     }
     else {
         /* Otherwise replace the error with caller's error object. */
-    	PyObject* t = PyTuple_New(1);
-    	PyTuple_SetItem(t, 0, PyObject_Type(item));
-    	truffle_invoke(PY_TRUFFLE_CEXT, "PyErr_Format", to_java(err), truffle_read_string("cannot fit '%s' into an index-sized integer"), to_java(t));
+    	PyErr_Format(err, "cannot fit '%s' into an index-sized integer", PyObject_Type(item));
     }
 
     Py_DECREF(value);
     return -1;
 }
 
 PyObject * PyNumber_Long(PyObject *o) {
-    PyObject *result = truffle_invoke(PY_TRUFFLE_CEXT, "PyNumber_Long", to_java(o));
-    if (result == ERROR_MARKER) {
-    	return NULL;
-    }
-    return to_sulong(result);
+    return UPCALL_CEXT_O("PyNumber_Long", native_to_java(o));
 }
 
 PyObject * PyNumber_Float(PyObject *o) {
-    PyObject *result = truffle_invoke(PY_TRUFFLE_CEXT, "PyNumber_Float", to_java(o));
-    if (result == ERROR_MARKER) {
-    	return NULL;
-    }
-    return to_sulong(result);
+    return UPCALL_CEXT_O("PyNumber_Float", native_to_java(o));
 }
 
 PyObject * PyNumber_Absolute(PyObject *o) {
-    void *result = polyglot_invoke(PY_TRUFFLE_CEXT, "PyNumber_Absolute", to_java(o));
-    if (result == ERROR_MARKER) {
-    	return NULL;
-    }
-    return to_sulong(result);
+    return UPCALL_CEXT_O("PyNumber_Absolute", native_to_java(o));
 }
 
 PyObject * PyNumber_Divmod(PyObject *a, PyObject *b) {
-    void *result = polyglot_invoke(PY_TRUFFLE_CEXT, "PyNumber_Divmod", to_java(a), to_java(b));
-    if (result == ERROR_MARKER) {
-    	return NULL;
-    }
-    return to_sulong(result);
+    return UPCALL_CEXT_O("PyNumber_Divmod", native_to_java(a), native_to_java(b));
 }
 
 
 PyObject * PyIter_Next(PyObject *iter) {
-	void* result = polyglot_invoke(PY_TRUFFLE_CEXT, "PyIter_Next", to_java(iter));
-	if (result == ERROR_MARKER && PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration)) {
-        PyErr_Clear();
-		return NULL;
-	}
-    return to_sulong(result);
+    return UPCALL_CEXT_O("PyIter_Next", native_to_java(iter));
 }
 
 int PySequence_Check(PyObject *s) {
 	if (s == NULL) {
 		return 0;
 	}
-	return polyglot_as_i64(polyglot_invoke(PY_TRUFFLE_CEXT, "PySequence_Check", to_java(s)));
+	return UPCALL_CEXT_I("PySequence_Check", native_to_java(s));
 }
 
 Py_ssize_t PySequence_Size(PyObject *s) {
-	return polyglot_as_i64(polyglot_invoke(PY_TRUFFLE_CEXT, "PyObject_Size", to_java(s)));
+    return UPCALL_CEXT_L("PyObject_Size", native_to_java(s));
 }
 
 // taken from CPython "Objects/abstract.c"
@@ -249,39 +214,23 @@ Py_ssize_t PySequence_Length(PyObject *s) {
 #define PySequence_Length PySequence_Size
 
 PyObject* PySequence_GetItem(PyObject *s, Py_ssize_t i) {
-	void* result = polyglot_invoke(PY_TRUFFLE_CEXT, "PySequence_GetItem", to_java(s), i);
-	if(result == ERROR_MARKER) {
-		return NULL;
-	}
-	return to_sulong(result);
+    return UPCALL_CEXT_O("PySequence_GetItem", native_to_java(s), i);
 }
 
 int PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o) {
-	return polyglot_as_i32(polyglot_invoke(PY_TRUFFLE_CEXT, "PySequence_SetItem", to_java(s), i, to_java(o)));
+    return UPCALL_CEXT_I("PySequence_SetItem", native_to_java(s), i, native_to_java(o));
 }
 
 PyObject* PySequence_Tuple(PyObject *v) {
-	void* result = polyglot_invoke(PY_TRUFFLE_CEXT, "PySequence_Tuple", to_java(v));
-	if(result == ERROR_MARKER) {
-		return NULL;
-	}
-	return to_sulong(result);
+    return UPCALL_CEXT_O("PySequence_Tuple", native_to_java(v));
 }
 
 PyObject * PySequence_Fast(PyObject *v, const char *m) {
-	void* result = polyglot_invoke(PY_TRUFFLE_CEXT, "PySequence_Fast", to_java(v), polyglot_from_string(m, "ascii"));
-	if(result == ERROR_MARKER) {
-		return NULL;
-	}
-	return to_sulong(result);
+    return UPCALL_CEXT_O("PySequence_Fast", native_to_java(v), polyglot_from_string(m, SRC_CS));
 }
 
 PyObject * PyMapping_GetItemString(PyObject *o, const char *key) {
-	void* result = polyglot_invoke(PY_TRUFFLE_CEXT, "PyObject_GetItem", to_java(o), polyglot_from_string(key, "utf-8"));
-	if(result == ERROR_MARKER) {
-		return NULL;
-	}
-	return to_sulong(result);
+    return UPCALL_CEXT_O("PyObject_GetItem", native_to_java(o), polyglot_from_string(key, SRC_CS));
 }
 
 // taken from CPython "Objects/abstract.c"

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

@@ -49,50 +49,32 @@ PyTypeObject PyBytes_Type = PY_TRUFFLE_TYPE("bytes", &PyType_Type, Py_TPFLAGS_DE
 PyObject* PyBytes_FromStringAndSize(const char* str, Py_ssize_t sz) {
     setlocale(LC_ALL, NULL);
     const char* encoding = nl_langinfo(CODESET);
-    return to_sulong(truffle_invoke(PY_TRUFFLE_CEXT, "PyBytes_FromStringAndSize", truffle_read_n_string(str, sz), truffle_read_string(encoding)));
+    void *jstr = str != NULL ? polyglot_from_string_n(str, sz, SRC_CS) : to_java(NULL);
+	return UPCALL_CEXT_O("PyBytes_FromStringAndSize", jstr, polyglot_from_string(encoding, SRC_CS));
 }
 
 PyObject * PyBytes_FromString(const char *str) {
 	setlocale(LC_ALL, NULL);
 	const char* encoding = nl_langinfo(CODESET);
-	return to_sulong(truffle_invoke(PY_TRUFFLE_CEXT, "PyBytes_FromStringAndSize", truffle_read_string(str), truffle_read_string(encoding)));
+	return UPCALL_CEXT_O("PyBytes_FromStringAndSize", polyglot_from_string(str, SRC_CS), polyglot_from_string(encoding, SRC_CS));
 }
 
 char* PyBytes_AsString(PyObject *obj) {
-	if (obj == NULL) {
-		return NULL;
-	}
-	// returns a Java byte array
- 	void *result = truffle_invoke(PY_TRUFFLE_CEXT, "PyTruffle_Bytes_AsString", to_java(obj), ERROR_MARKER);
- 	if (result == ERROR_MARKER) {
- 		return NULL;
- 	}
- 	if(truffle_has_size(result)) {
- 		int n = truffle_get_size(result);
- 		char *barr = (char *) malloc(n*sizeof(char));
-
- 		// we need to read element-by-element
- 		int i;
- 		for(i=0; i < n; i++) {
- 			barr[i] = truffle_read_idx_c(result, i);
- 		}
- 		return barr;
- 	}
- 	return NULL;
+    return UPCALL_CEXT_NOCAST("PyTruffle_Bytes_AsString", native_to_java(obj), ERROR_MARKER);
 }
 
 int PyBytes_AsStringAndSize(PyObject *obj, char **s, Py_ssize_t *len) {
 	setlocale(LC_ALL, NULL);
 	const char* encoding = nl_langinfo(CODESET);
- 	PyObject *result = to_sulong(truffle_invoke(PY_TRUFFLE_CEXT, "PyBytes_AsStringCheckEmbeddedNull", to_java(obj), truffle_read_string(encoding)));
+	PyObject *result = UPCALL_CEXT_O("PyBytes_AsStringCheckEmbeddedNull", native_to_java(obj), polyglot_from_string(encoding, SRC_CS));
  	if(result == NULL) {
  		return -1;
  	}
 
  	*s = as_char_pointer(result);
 
     if (len != NULL) {
-    	*len = truffle_invoke_i(PY_TRUFFLE_CEXT, "PyObject_LEN", to_java(obj));
+        *len = polyglot_as_i64(polyglot_invoke(PY_TRUFFLE_CEXT, "PyTruffle_Object_LEN", native_to_java(obj)));
     }
 
     return 0;
@@ -218,17 +200,16 @@ PyBytes_FromFormatV(const char *format, va_list vargs) {
 
         default:
             // TODO correctly handle this case
-            return to_sulong(truffle_invoke(PY_TRUFFLE_CEXT, "PyBytes_FromFormat", truffle_read_string(format), f+i));
-
+            return UPCALL_CEXT_O("PyBytes_FromFormat", polyglot_from_string(format, SRC_CS), f+i);
         }
     }
 
 
-#define SETARG(__args, __i, __arg) truffle_invoke(PY_TRUFFLE_CEXT, "PyTuple_SetItem", (__args), (__i), (__arg));
+#define SETARG(__args, __i, __arg) UPCALL_CEXT_I("PyTuple_SetItem", native_to_java(__args), (__i), (__arg))
 
     // do actual conversion using one-character type specifiers
     int conversions = strlen(buffer);
-    PyObject* args = to_java(PyTuple_New(conversions));
+    PyObject* args = PyTuple_New(conversions);
     for (int i=0; i < conversions; i++) {
     	switch(buffer[i]) {
     	case 'c':
@@ -250,19 +231,18 @@ PyBytes_FromFormatV(const char *format, va_list vargs) {
             SETARG(args, i, va_arg(vargs, size_t));
             break;
     	case 's':
-            SETARG(args, i, truffle_read_string(va_arg(vargs, const char*)));
+            SETARG(args, i, polyglot_from_string(va_arg(vargs, const char*), SRC_CS));
     		break;
     	case 'p':
-            SETARG(args, i, to_java(va_arg(vargs, void*)));
+            SETARG(args, i, native_to_java(va_arg(vargs, void*)));
     		break;
     	}
     }
-    PyObject *res = to_sulong(truffle_invoke(PY_TRUFFLE_CEXT, "PyBytes_FromFormat", truffle_read_string(format), args));
-    return res;
+    return UPCALL_CEXT_O("PyBytes_FromFormat", polyglot_from_string(format, SRC_CS), native_to_java(args));
 }
 
 void PyBytes_Concat(PyObject **bytes, PyObject *newpart) {
-    *bytes = to_sulong(truffle_invoke(PY_TRUFFLE_CEXT, "PyBytes_Concat", to_java(*bytes), to_java(newpart)));
+    *bytes = UPCALL_CEXT_O("PyBytes_Concat", native_to_java(*bytes), native_to_java(newpart));
 }
 
 void PyBytes_ConcatAndDel(PyObject **bytes, PyObject *newpart) {
@@ -271,9 +251,17 @@ void PyBytes_ConcatAndDel(PyObject **bytes, PyObject *newpart) {
 }
 
 Py_ssize_t PyBytes_Size(PyObject *bytes) {
-	return truffle_invoke_i(PY_TRUFFLE_CEXT, "PyBytes_Size", to_java(bytes));
+    return UPCALL_CEXT_L("PyBytes_Size", native_to_java(bytes));
 }
 
 int bytes_buffer_getbuffer(PyBytesObject *self, Py_buffer *view, int flags) {
     return PyBuffer_FillInfo(view, (PyObject*)self, (void *)self->ob_sval, Py_SIZE(self), 1, flags);
 }
+
+int bytes_copy2mem(char* target, char* source, size_t nbytes) {
+    size_t i;
+    for (i = 0; i < nbytes; i++) {
+        target[i] = source[i];
+    }
+    return 0;
+}