]> gerrit.simantics Code Review - simantics/python.git/blobdiff - org.simantics.pythonlink.win32.x86_64/src/sclpy.c
Several updates to Pyhthon-link behaviour.
[simantics/python.git] / org.simantics.pythonlink.win32.x86_64 / src / sclpy.c
index 686221e2ac09da96874dc03c7c5abb857495b2e2..b2308bcdd3b4af57192c0fbd5a3dfa1ad6801e9f 100644 (file)
@@ -1,14 +1,15 @@
-///////////////////////////////////////////////////////
-//                                                   //
-//   VTT Technical Research Centre of Finland LTD    //
-//   For internal use only. Do not redistribute.     //
-//                                                   //
-//   Authors:                                        //
-//       Antton Tapani    ext-antton.tapani@vtt.fi   //
-//                                                   //
-//   Last modified by Antton Tapani    9.2016        //
-//                                                   //
-///////////////////////////////////////////////////////
+/*******************************************************************************
+ * Copyright (c) 2017-2019 Association for Decentralized Information Management in
+ * Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     VTT Technical Research Centre - Initial API and implementation
+ *     Semantum Oy - Improvements
+ *******************************************************************************/
 
 #include "sclpy.h"
 
@@ -32,6 +33,7 @@ jint throwIllegalArgumentException( JNIEnv *env, const char *message ) {
        return throwException( env, ILLEGAL_ARGUMENT_EXCEPTION, message );
 }
 
+// Returns a borrowed reference.
 PyObject* getModule(jlong contextID) {
        return PyState_FindModule((PyModuleDef*) contextID);
 //     return PyImport_AddModule("__main__");
@@ -48,50 +50,97 @@ static PyObject *
 writeToSCL(PyObject *self, PyObject *args)
 {
     if (currentEnv != NULL && sclWriter != NULL) {
+       wchar_t *what;
+               Py_ssize_t length;
        JNIEnv *env = currentEnv;
 
-               Py_UNICODE *what;
-               Py_ssize_t length;
                if (!PyArg_ParseTuple(args, "u#", &what, &length))
-                       return Py_BuildValue("");
+                       Py_RETURN_NONE;
 
                {
-               jclass writerClass = (*env)->FindClass(env, WRITER_CLASS);
-               jmethodID writeMethod = (*env)->GetMethodID(env, writerClass, "write", "([CII)V");
-               jcharArray chars = (*env)->NewCharArray(env, (jsize)length);
-
-               (*env)->SetCharArrayRegion(env, chars, 0, length, what);
-               (*env)->CallVoidMethod(env, sclWriter, writeMethod, chars, 0, length);
+                       PyThreadState *my_ts = PyThreadState_Get();
+                       if (my_ts == main_ts) {
+                               jclass writerClass = (*env)->FindClass(env, WRITER_CLASS);
+                               jmethodID writeMethod = (*env)->GetMethodID(env, writerClass, "write", "([CII)V");
+                               jcharArray chars = (*env)->NewCharArray(env, (jsize)length);
+
+                               (*env)->SetCharArrayRegion(env, chars, 0, length, what);
+                               Py_BEGIN_ALLOW_THREADS
+                               (*env)->CallVoidMethod(env, sclWriter, writeMethod, chars, 0, length);
+                               Py_END_ALLOW_THREADS
+                       } else {
+                               //TODO
+                       }
                }
     }
 
-    return Py_BuildValue("");
+       Py_RETURN_NONE;
+}
+
+static PyObject *
+flushSCL(PyObject *self, PyObject *args)
+{
+    if (currentEnv != NULL && sclWriter != NULL) {
+       JNIEnv *env = currentEnv;
+       PyThreadState *my_ts = PyThreadState_Get();
+       if (my_ts != main_ts) {
+               // TODO: Process calls from other threads
+                       Py_RETURN_NONE;
+       }
+
+       {
+                       jclass writerClass = (*env)->FindClass(env, WRITER_CLASS);
+                       jmethodID flushMethod = (*env)->GetMethodID(env, writerClass, "flush", "()V");
+
+               Py_BEGIN_ALLOW_THREADS
+                       (*env)->CallVoidMethod(env, sclWriter, flushMethod);
+                       Py_END_ALLOW_THREADS
+       }
+    }
+
+    Py_RETURN_NONE;
 }
 
 static PyMethodDef sclWriterMethods[] = {
     {"write", writeToSCL, METH_VARARGS, "Write something."},
+       {"flush", flushSCL, METH_VARARGS, "Flush output."},
     {NULL, NULL, 0, NULL}
 };
 
+JNIEXPORT void JNICALL
+Java_org_simantics_pythonlink_PythonContext_initializePython(
+        JNIEnv *env, jobject thisObj, jobject writer) {
+    Py_InitializeEx(0);
 
-JNIEXPORT jlong JNICALL Java_org_simantics_pythonlink_PythonContext_createContextImpl(JNIEnv *env, jobject thisObj) {
-       char name[16];
+    {
+       static struct PyModuleDef moduledef = {
+           PyModuleDef_HEAD_INIT, "sclwriter", NULL, -1, sclWriterMethods
+       };
+       PyObject *m = PyModule_Create(&moduledef);
+
+       sclWriter = (*env)->NewGlobalRef(env, writer);
+
+       if (m == NULL) {
+           throwException(env, PYTHON_EXCEPTION,
+                          "Failed to create SCL writer module");
+       } else {
+           PySys_SetObject("stdout", m);
+           PySys_SetObject("stderr", m);
+           Py_DECREF(m);
+       }
+    }
 
-       if (!main_ts) {
-        Py_Initialize();
+       hasNumpy = _import_array();
+       hasNumpy = hasNumpy != -1;
 
-        {
-               static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "sclwriter", NULL, -1, sclWriterMethods, };
-                       PyObject *m = PyModule_Create(&moduledef);
+       main_ts = PyEval_SaveThread();
+}
 
-               if (m == NULL) throwException(env, PYTHON_EXCEPTION, "Failed to create SCL writer module");
-                       PySys_SetObject("stdout", m);
-                       PySys_SetObject("stderr", m);
-        }
+JNIEXPORT jlong JNICALL Java_org_simantics_pythonlink_PythonContext_createContextImpl(JNIEnv *env, jobject thisObj) {
+       char name[16];
 
-       hasNumpy = _import_array();
-       hasNumpy = hasNumpy != -1;
-       main_ts = PyEval_SaveThread();
+       if (!main_ts) {
+               return 0;
        }
 
        sprintf(name, "SCL_%d", ++moduleCount);
@@ -106,12 +155,11 @@ JNIEXPORT jlong JNICALL Java_org_simantics_pythonlink_PythonContext_createContex
                modDef->m_size = -1;
 
                module = PyModule_Create(modDef);
-               Py_INCREF(module);
                PyState_AddModule(module, modDef);
-
                {
                        PyObject *builtin = PyImport_AddModule("builtins");
                        PyObject *dict = PyModule_GetDict(module);
+                       Py_DECREF(module);
                        PyDict_SetItemString(dict, "__builtin__", builtin);
                        PyDict_SetItemString(dict, "__builtins__", builtin);
 
@@ -121,12 +169,11 @@ JNIEXPORT jlong JNICALL Java_org_simantics_pythonlink_PythonContext_createContex
        }
 }
 
-JNIEXPORT void JNICALL Java_org_simantics_pythonlink_PythonContext_deleteContextImpl(JNIEnv *env, jobject thisObj, jlong contextID) {
+JNIEXPORT void JNICALL
+Java_org_simantics_pythonlink_PythonContext_deleteContextImpl(
+               JNIEnv *env, jobject thisObj, jlong contextID) {
        PyModuleDef *modDef = (PyModuleDef*)contextID;
-       PyObject *module;
        PyEval_RestoreThread(main_ts);
-       module = PyState_FindModule(modDef);
-       Py_XDECREF(module);
        PyState_RemoveModule(modDef);
        free((char*)modDef->m_name);
        free(modDef);
@@ -165,6 +212,7 @@ PyObject *getPythonStringList(JNIEnv *env, jobjectArray value) {
                        PyList_SetItem(result, i, getPythonString(env, (jstring)item));
                }
                else {
+                       Py_INCREF(Py_None);
                        PyList_SetItem(result, i, Py_None);
                }
        }
@@ -377,8 +425,12 @@ PyObject *getPythonRecordObject(JNIEnv *env, jobject object, jobject binding) {
                jobject componentObject = (*env)->CallObjectMethod(env, binding, getComponent, object, i);
                jobject componentBinding = (*env)->CallObjectMethod(env, binding, getComponentBinding, i);
 
-               PyObject *item = getPythonObject(env, componentObject, componentBinding);
-               PyDict_SetItem(result, getPythonString(env, fieldName), item);
+               PyObject
+                       *key = getPythonString(env, fieldName),
+                       *item = getPythonObject(env, componentObject, componentBinding);
+               PyDict_SetItem(result, key, item);
+               Py_DECREF(key);
+               Py_DECREF(item);
        }
 
        return result;
@@ -401,8 +453,10 @@ PyObject *getPythonArrayObject(JNIEnv *env, jobject object, jobject binding) {
                jobject item = (*env)->CallObjectMethod(env, binding, getMethod, object, i);
                if (item != NULL)
                        PyList_SetItem(result, i, getPythonObject(env, item, componentBinding));
-               else
+               else {
+                       Py_INCREF(Py_None);
                        PyList_SetItem(result, i, Py_None);
+               }
        }
 
        return result;
@@ -431,7 +485,12 @@ PyObject *getPythonMapObject(JNIEnv *env, jobject object, jobject binding) {
        for (i = 0; i < size; i++) {
                jobject key = (*env)->GetObjectArrayElement(env, keys, i);
                jobject item = (*env)->GetObjectArrayElement(env, values, i);
-               PyDict_SetItem(result, getPythonObject(env, key, keyBinding), getPythonObject(env, item, valueBinding));
+               PyObject
+                       *pkey = getPythonObject(env, key, keyBinding),
+                       *pitem = getPythonObject(env, item, valueBinding);
+               PyDict_SetItem(result, pkey, pitem);
+               Py_DECREF(pkey);
+               Py_DECREF(pitem);
        }
 
        (*env)->DeleteLocalRef(env, keys);
@@ -562,6 +621,7 @@ PyObject *getPythonObject(JNIEnv *env, jobject value, jobject binding) {
        }
 }
 
+// Steals refs to name & value.
 void setPythonVariable(PyObject *module, PyObject *name, PyObject *value) {
        if (name && value) {
                PyDict_SetItem(PyModule_GetDict(module), name, value);
@@ -651,9 +711,11 @@ jobjectArray pythonSequenceAsStringArray(JNIEnv *env, PyObject *seq) {
                PyObject *item = PySequence_GetItem(seq, i);
                if (PyUnicode_Check(item)) {
                        jstring value = pythonStringAsJavaString(env, item);
+                       Py_DECREF(item);
                        (*env)->SetObjectArrayElement(env, array, i, value);
                }
                else {
+                       Py_DECREF(item);
                        throwPythonException(env, "List item not a string");
                        return NULL;
                }
@@ -672,10 +734,12 @@ jdoubleArray pythonSequenceAsDoubleArray(JNIEnv *env, PyObject *seq) {
        for (i = 0; i < jlen; i++) {
                PyObject *item = PySequence_GetItem(seq, i);
                if (PyFloat_Check(item)) {
-                       double value = PyFloat_AsDouble(item);
+                       jdouble value = PyFloat_AsDouble(item);
+                       Py_DECREF(item);
                        (*env)->SetDoubleArrayRegion(env, array, i, 1, &value);
                }
                else {
+                       Py_DECREF(item);
                        throwPythonException(env, "List item not a floating point value");
                        return NULL;
                }
@@ -715,6 +779,7 @@ jobjectArray pythonSequenceAsObjectArray(JNIEnv *env, PyObject *seq) {
        for (i = 0; i < jlen; i++) {
                PyObject *item = PySequence_GetItem(seq, i);
                jobject object = pythonObjectAsObject(env, item);
+               Py_DECREF(item);
                (*env)->SetObjectArrayElement(env, array, i, object);
        }
 
@@ -732,9 +797,11 @@ jbooleanArray pythonSequenceAsBooleanArray(JNIEnv *env, PyObject *seq) {
                PyObject *item = PySequence_GetItem(seq, i);
                if (PyBool_Check(item)) {
                        jboolean value = item == Py_True;
+                       Py_DECREF(item);
                        (*env)->SetBooleanArrayRegion(env, array, i, 1, &value);
                }
                else {
+                       Py_DECREF(item);
                        throwPythonException(env, "List item not a boolean");
                        return NULL;
                }
@@ -754,9 +821,11 @@ jintArray pythonSequenceAsIntegerArray(JNIEnv *env, PyObject *seq) {
                PyObject *item = PySequence_GetItem(seq, i);
                if (PyLong_Check(item)) {
                        jint value = PyLong_AsLong(item);
+                       Py_DECREF(item);
                        (*env)->SetIntArrayRegion(env, array, i, 1, &value);
                }
                else {
+                       Py_DECREF(item);
                        throwPythonException(env, "List item not an integer");
                        return NULL;
                }
@@ -776,9 +845,11 @@ jlongArray pythonSequenceAsLongArray(JNIEnv *env, PyObject *seq) {
                PyObject *item = PySequence_GetItem(seq, i);
                if (PyLong_Check(item)) {
                        jlong value = PyLong_AsLongLong(item);
+                       Py_DECREF(item);
                        (*env)->SetLongArrayRegion(env, array, i, 1, &value);
                }
                else {
+                       Py_DECREF(item);
                        throwPythonException(env, "List item not an integer");
                        return NULL;
                }
@@ -914,6 +985,59 @@ Java_org_simantics_pythonlink_PythonContext_setPythonVariantVariableImpl(
        PyEval_SaveThread();
 }
 
+static PyObject *getExceptionMessage(PyObject *exceptionType, PyObject *exception, PyObject *traceback) {
+       PyObject *formatExc = NULL, *args = NULL;
+       PyObject *tracebackModule = PyImport_ImportModule("traceback");
+       if (!tracebackModule) {
+               fputs("Python: No traceback module\n", stderr);
+               return NULL;
+       }
+
+       PyErr_NormalizeException(&exceptionType, &exception, &traceback);
+       
+       if (exception && traceback) {
+               formatExc = PyDict_GetItemString(PyModule_GetDict(tracebackModule), "format_exception");
+               args = PyTuple_Pack(3, exceptionType, exception, traceback);
+       }
+       else if (exception) {
+               formatExc = PyDict_GetItemString(PyModule_GetDict(tracebackModule), "format_exception_only");
+               args = PyTuple_Pack(2, exceptionType, exception);
+       }
+
+       if (formatExc != NULL && args != NULL) {
+               PyObject *result = PyObject_CallObject(formatExc, args);
+               if (!result) {
+                       fputs("Python: No result from format_exception\n", stderr);
+                       // Fallback to a direct string representation of the exception object
+                       result = PyObject_Str(exception);
+               }
+               Py_XDECREF(args);
+               // Py_XDECREF(formatExc) - Borrowed reference
+               Py_DECREF(tracebackModule);
+
+               return result;
+       }
+       else {
+               if (!formatExc) fputs("Python: No format_exception\n", stderr);
+
+               Py_XDECREF(args);
+               // Py_XDECREF(formatExc) - Borrowed reference
+               Py_DECREF(tracebackModule);
+
+               return NULL;
+       }
+}
+
+static void throwExceptionType(JNIEnv *env, PyObject *exceptionType) {
+       PyObject *ty_name = exceptionType ? PyObject_GetAttrString(exceptionType, "__name__") : NULL;
+       PyObject *str = ty_name ? PyUnicode_AsEncodedString(ty_name, "utf-8", "ignore") : NULL;
+
+       throwPythonException(env, str ? PyBytes_AsString(str) : "Internal error - no exception type");
+
+       Py_XDECREF(str);
+       Py_XDECREF(ty_name);
+}
+
 JNIEXPORT jint JNICALL
 Java_org_simantics_pythonlink_PythonContext_executePythonStatementImpl(
                JNIEnv *env, jobject thisObj, jlong contextID, jstring statement) {
@@ -924,77 +1048,68 @@ Java_org_simantics_pythonlink_PythonContext_executePythonStatementImpl(
        {
                PyObject *module = getModule(contextID);
 
-               jclass sclReportingWriterClass = (*env)->FindClass(env, SCL_REPORTING_WRITER_CLASS);
-               jmethodID constructor = (*env)->GetMethodID(env, sclReportingWriterClass, "<init>", "()V");
-               jmethodID flushMethod = (*env)->GetMethodID(env, sclReportingWriterClass, "flush", "()V");
-
                PyObject *globals;
 
                globals = PyModule_GetDict(module);
 
                currentEnv = env;
-               if (sclReportingWriterClass && constructor)
-                       sclWriter = (*env)->NewObject(env, sclReportingWriterClass, constructor);
-               else
-                       sclWriter = NULL;
 
                {
-                       PyObject *result = PyRun_String(utfchars, Py_file_input, globals, globals);
-
+                       // PyObject *result = PyRun_String(utfchars, Py_file_input, globals, globals); - Not available in Py_LIMITED_API
+                       PyObject *code = Py_CompileString(utfchars, "SCL_INPUT", Py_file_input);
+                       PyObject *result = code ? PyEval_EvalCode(code,globals, globals) : NULL;
                        PyObject *exceptionType = PyErr_Occurred();
+
                        if (exceptionType != NULL) {
-                               PyObject *exception, *traceback;
+                               PyObject *exception, *traceback, *message;
                                PyErr_Fetch(&exceptionType, &exception, &traceback);
 
-                               {
-                                       PyObject *tracebackModule = PyImport_ImportModule("traceback");
-                                       if (tracebackModule != NULL) {
-                                               PyObject *formatExc = PyDict_GetItemString(PyModule_GetDict(tracebackModule), "format_exception");
-                                               if (formatExc != NULL) {
-                                                       PyObject *args = PyTuple_Pack(3, exceptionType, exception, traceback);
-                                                       PyObject *message = PyObject_CallObject(formatExc, args);
-                                                       if (message != NULL) {
-                                                               PyObject *emptyStr = PyUnicode_FromString("");
-                                                               PyObject *joined = PyUnicode_Join(emptyStr, message);
-                                                               char *messageStr = PyUnicode_AsUTF8(joined);
-                                                               throwPythonException(env, messageStr);
-                                                               Py_DECREF(joined);
-                                                               Py_DECREF(emptyStr);
-                                                               Py_DECREF(message);
-                                                       }
-                                                       else {
-                                                               PyTypeObject
-                                                                       *ty = (PyTypeObject *)exceptionType;
-                                                               throwPythonException(
-                                                                               env, ty ? ty->tp_name
-                                                                                               : "Internal error, null exception type");
-                                                       }
-                                                       Py_DECREF(args);
-                                                       Py_DECREF(formatExc);
+                               message = getExceptionMessage(exceptionType, exception, traceback);
+                               if (message != NULL) {
+                                       if (PyList_Check(message)) {
+                                               PyObject *emptyStr = PyUnicode_FromString("");
+                                               PyObject *temp = PyUnicode_Join(emptyStr, message);
+                                               if (temp) {
+                                                       Py_DECREF(message);
+                                                       message = temp;
                                                }
-                                               else {
-                                                       throwPythonException(env, "Internal error, no format_exc function");
+
+                                               Py_DECREF(emptyStr);
+                                       }
+
+                                       if (!PyUnicode_Check(message)) {
+                                               PyObject *temp = PyObject_Str(message);
+                                               if (temp) {
+                                                       Py_DECREF(message);
+                                                       message = temp;
                                                }
-                                               Py_DECREF(tracebackModule);
+                                       }
+
+                                       PyObject* str = PyUnicode_AsEncodedString(message, "utf-8", "ignore");
+                                       Py_DECREF(message);
+
+                                       if (str != NULL) {
+                                               throwPythonException(env, PyBytes_AsString(str));
+                                               Py_DECREF(str);
                                        }
                                        else {
-                                               throwPythonException(env, "Internal error, no traceback module");
+                                               fputs("Python: Encoding message string failed\n", stderr);
+                                               throwExceptionType(env, exceptionType);
                                        }
                                }
-                               Py_XDECREF(exceptionType);
-                               Py_XDECREF(exception);
-                               Py_XDECREF(traceback);
+                               else {
+                                       fputs("Python: No exception message\n", stderr);
+                                       throwExceptionType(env, exceptionType);
+                               }
                        }
 
+                       Py_XDECREF(result);
+                       Py_XDECREF(code);
+
                        PyEval_SaveThread();
                        (*env)->ReleaseStringUTFChars(env, statement, utfchars);
 
-                       if (sclWriter != NULL) {
-                               (*env)->CallVoidMethod(env, sclWriter, flushMethod);
-                       }
-
                        currentEnv = NULL;
-                       sclWriter = NULL;
 
                        return result != NULL ? 0 : 1;
                }
@@ -1004,7 +1119,7 @@ Java_org_simantics_pythonlink_PythonContext_executePythonStatementImpl(
 // Returns a borrowed reference.
 static PyObject *getPythonValue(
                JNIEnv *env, jlong contextID, jstring variableName) {
-       PyObject *module = getModule(contextID);
+    PyObject *module = getModule(contextID);
     PyObject *pythonName = getPythonString(env, variableName);
     PyObject *value = PyDict_GetItem(PyModule_GetDict(module), pythonName);