X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.pythonlink.win32.x86_64%2Fsrc%2Fsclpy.c;h=1592a2f56de443ddc298ad847a17f48175e04b02;hb=8885425046e0f89893c0e1ee0fe5c27948dcd2be;hp=8e41834ee1d2c505bc0a8e4764782e4c08323503;hpb=025afe064401dba02dd70cf3daa1b94d52966aa8;p=simantics%2Fpython.git

diff --git a/org.simantics.pythonlink.win32.x86_64/src/sclpy.c b/org.simantics.pythonlink.win32.x86_64/src/sclpy.c
index 8e41834..1592a2f 100644
--- a/org.simantics.pythonlink.win32.x86_64/src/sclpy.c
+++ b/org.simantics.pythonlink.win32.x86_64/src/sclpy.c
@@ -14,7 +14,7 @@
 
 #include <windows.h>
 
-jint throwException( JNIEnv *env, char *className, char *message )
+jint throwException( JNIEnv *env, char *className, const char *message )
 {
     jclass exClass = (*env)->FindClass( env, className);
     if (exClass == NULL) {
@@ -24,46 +24,151 @@ jint throwException( JNIEnv *env, char *className, char *message )
     return (*env)->ThrowNew( env, exClass, message );
 }
 
-jint throwPythonException( JNIEnv *env, char *message ) {
+jint throwPythonException( JNIEnv *env, const char *message ) {
 	return throwException( env, PYTHON_EXCEPTION, message );
 }
 
-jint throwIllegalArgumentException( JNIEnv *env, char *message ) {
+jint throwIllegalArgumentException( JNIEnv *env, const char *message ) {
 	return throwException( env, ILLEGAL_ARGUMENT_EXCEPTION, message );
 }
 
+PyObject* getModule(jlong contextID) {
+	return PyState_FindModule((PyModuleDef*) contextID);
+//	return PyImport_AddModule("__main__");
+}
+
 int moduleCount = 0;
 int hasNumpy = 0;
 PyThreadState *main_ts = 0;
 
+static JNIEnv *currentEnv = NULL;
+jobject sclWriter = NULL;
+
+static PyObject *
+writeToSCL(PyObject *self, PyObject *args)
+{
+    if (currentEnv != NULL && sclWriter != NULL) {
+		Py_UNICODE *what;
+		Py_ssize_t length;
+    	JNIEnv *env = currentEnv;
+
+		if (!PyArg_ParseTuple(args, "u#", &what, &length))
+			Py_RETURN_NONE;
+
+		{
+			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
+			}
+		}
+    }
+
+	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_Initialize();
+
+    {
+    	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");
+
+		PySys_SetObject("stdout", m);
+		PySys_SetObject("stderr", m);
+    }
+
+	hasNumpy = _import_array();
+	hasNumpy = hasNumpy != -1;
+
+	main_ts = PyEval_SaveThread();
+}
+
 JNIEXPORT jlong JNICALL Java_org_simantics_pythonlink_PythonContext_createContextImpl(JNIEnv *env, jobject thisObj) {
 	char name[16];
 
 	if (!main_ts) {
-        Py_Initialize();
-
-    	hasNumpy = _import_array();
-    	hasNumpy = hasNumpy != -1;
-    	main_ts = PyEval_SaveThread();
+		return 0;
 	}
 
 	sprintf(name, "SCL_%d", ++moduleCount);
 
 	PyEval_RestoreThread(main_ts);
 	{
-		PyObject *module = PyModule_New(name);
-		PyObject *main = PyImport_AddModule("__main__");
+		PyObject *module;
+		PyModuleDef *modDef = malloc(sizeof(PyModuleDef));
+		memset(modDef, 0, sizeof(PyModuleDef));
+		modDef->m_name = strdup(name);
+		modDef->m_doc = NULL;
+		modDef->m_size = -1;
 
-		PyDict_Merge(PyModule_GetDict(module), PyModule_GetDict(main), 0);
-		PyEval_SaveThread();
-		return (jlong)module;
+		module = PyModule_Create(modDef);
+		Py_INCREF(module);
+		PyState_AddModule(module, modDef);
+
+		{
+			PyObject *builtin = PyImport_AddModule("builtins");
+			PyObject *dict = PyModule_GetDict(module);
+			PyDict_SetItemString(dict, "__builtin__", builtin);
+			PyDict_SetItemString(dict, "__builtins__", builtin);
+
+			PyEval_SaveThread();
+			return (jlong)modDef;
+		}
 	}
 }
 
 JNIEXPORT void JNICALL Java_org_simantics_pythonlink_PythonContext_deleteContextImpl(JNIEnv *env, jobject thisObj, jlong contextID) {
-	PyObject *module = (PyObject*)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);
 	PyEval_SaveThread();
 }
 
@@ -791,9 +896,10 @@ jobject pythonDictionaryAsMap(JNIEnv *env, PyObject *dict) {
     ##VariableImpl(                                                     \
         JNIEnv *env, jobject thisObj, jlong contextID, jstring variableName, \
         jtype value) {                                                  \
-            PyObject *module = (PyObject*)contextID;                    \
+            PyObject *module;                                           \
                                                                         \
             PyEval_RestoreThread(main_ts);                              \
+            module = getModule(contextID);                              \
             setPythonVariable(module, getPythonString(env, variableName), \
                               j2py(env, value));                        \
             PyEval_SaveThread();                                        \
@@ -818,8 +924,6 @@ JNIEXPORT void JNICALL
 Java_org_simantics_pythonlink_PythonContext_setPythonNDArrayVariableImpl(
 		JNIEnv *env, jobject thisObj, jlong contextID, jstring variableName,
 		jobject value) {
-	PyObject *module = (PyObject*)contextID;
-
 	if (!hasNumpy) {
 		throwPythonException(env, "Importing numpy failed");
 		return;
@@ -827,6 +931,7 @@ Java_org_simantics_pythonlink_PythonContext_setPythonNDArrayVariableImpl(
 
 	PyEval_RestoreThread(main_ts);
 	{
+		PyObject *module = getModule(contextID);
 		PyObject *pythonName = getPythonString(env, variableName);
 		PyObject *val = getPythonNDArray(env, value);
 
@@ -839,71 +944,88 @@ JNIEXPORT void JNICALL
 Java_org_simantics_pythonlink_PythonContext_setPythonVariantVariableImpl(
 		JNIEnv *env, jobject thisObj, jlong contextID, jstring variableName,
 		jobject value, jobject binding) {
-	PyObject *module = (PyObject*)contextID;
+	PyObject *module;
 
 	PyEval_RestoreThread(main_ts);
+	module = getModule(contextID);
 	setPythonVariable(module, getPythonString(env, variableName),
 					  getPythonObject(env, value, binding));
 	PyEval_SaveThread();
 }
 
+static PyObject *getExceptionMessage(PyObject *exceptionType, PyObject *exception, PyObject *traceback) {
+	PyObject *formatExc = NULL, *args = NULL;
+	PyObject *tracebackModule = PyImport_ImportModule("traceback");
+	if (!tracebackModule) {
+		return NULL;
+	}
+
+	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);
+	}
+
+	Py_DECREF(tracebackModule);
+
+	if (formatExc != NULL && args != NULL) {
+		PyObject *result = PyObject_CallObject(formatExc, args);
+		Py_XDECREF(args);
+		Py_XDECREF(formatExc);
+		return result;
+	}
+	else {
+		Py_XDECREF(args);
+		Py_XDECREF(formatExc);
+		return NULL;
+	}
+}
+
 JNIEXPORT jint JNICALL
 Java_org_simantics_pythonlink_PythonContext_executePythonStatementImpl(
 		JNIEnv *env, jobject thisObj, jlong contextID, jstring statement) {
-	PyObject *module = (PyObject*)contextID;
-
 	const char *utfchars = (*env)->GetStringUTFChars(env, statement, NULL);
 
 	PyEval_RestoreThread(main_ts);
 	PyErr_Clear();
 	{
+		PyObject *module = getModule(contextID);
+
 		PyObject *globals;
 
 		globals = PyModule_GetDict(module);
 
+		currentEnv = env;
+
 		{
 			PyObject *result = PyRun_String(utfchars, Py_file_input, globals, globals);
 
 			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);
-						}
-						else {
-							throwPythonException(env, "Internal error, no format_exc function");
-						}
-						Py_DECREF(tracebackModule);
-					}
-					else {
-						throwPythonException(env, "Internal error, no traceback module");
-					}
+				message = getExceptionMessage(exceptionType, exception, traceback);
+				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_XDECREF(exceptionType);
 				Py_XDECREF(exception);
 				Py_XDECREF(traceback);
@@ -912,16 +1034,17 @@ Java_org_simantics_pythonlink_PythonContext_executePythonStatementImpl(
 			PyEval_SaveThread();
 			(*env)->ReleaseStringUTFChars(env, statement, utfchars);
 
+			currentEnv = NULL;
+
 			return result != NULL ? 0 : 1;
 		}
 	}
 }
 
-
 // Returns a borrowed reference.
 static PyObject *getPythonValue(
 		JNIEnv *env, jlong contextID, jstring variableName) {
-    PyObject *module = (PyObject*)contextID;
+	PyObject *module = getModule(contextID);
     PyObject *pythonName = getPythonString(env, variableName);
     PyObject *value = PyDict_GetItem(PyModule_GetDict(module), pythonName);
 
@@ -1041,7 +1164,7 @@ Java_org_simantics_pythonlink_PythonContext_getPythonVariableNamesImpl(
 	jobjectArray result = NULL;
 	PyEval_RestoreThread(main_ts);
 	{
-		PyObject *module = (PyObject*)contextID;
+		PyObject *module = getModule(contextID);
 		PyObject *dict = PyModule_GetDict(module);
 
 		PyObject *keys = PyDict_Keys(dict);