plugins/python-loader/gnm-py-interpreter.c

   1 /*
   2  * gnm-py-interpreter.c : GObject wrapper around Python interpreter
   3  *
   4  * Author: Zbigniew Chyla (cyba@gnome.pl)
   5  */
   6
   7 #include <gnumeric-config.h>
   8 #include <Python.h>
   9 #include <gnumeric.h>
  10 #include <gutils.h>
  11 #include "py-gnumeric.h"
  12 #include "gnm-py-interpreter.h"
  13 #include "gnm-python.h"
  14
  15 #include <goffice/goffice.h>
  16 #include <goffice/app/module-plugin-defs.h>
  17 #include <gsf/gsf-impl-utils.h>
  18 #include <glib/gi18n-lib.h>
  19
  20 struct _GnmPyInterpreter {
  21         GObject parent_instance;
  22
  23         PyThreadState *py_thread_state;
  24         PyObject      *stringio_class;
  25         GOPlugin *plugin;
  26 };
  27
  28 typedef struct {
  29         GObjectClass parent_class;
  30
  31         void (*set_current) (GnmPyInterpreter *interpreter);
  32 } GnmPyInterpreterClass;
  33
  34 enum {
  35         SET_CURRENT_SIGNAL,
  36         LAST_SIGNAL
  37 };
  38
  39 static guint signals[LAST_SIGNAL] = { 0 };
  40 static GObjectClass *parent_class = NULL;
  41
  42 static void
  43 gnm_py_interpreter_init (GnmPyInterpreter *interpreter)
  44 {
  45         interpreter->py_thread_state = NULL;
  46         interpreter->stringio_class  = NULL;
  47         interpreter->plugin = NULL;
  48 }
  49
  50 static void
  51 gnm_py_interpreter_finalize (GObject *obj)
  52 {
  53         GnmPyInterpreter *interpreter = GNM_PY_INTERPRETER (obj);
  54
  55         if (interpreter->stringio_class != NULL) {
  56                 Py_DECREF (interpreter->stringio_class);
  57         }
  58
  59         parent_class->finalize (obj);
  60 }
  61
  62 static void
  63 gnm_py_interpreter_class_init (GObjectClass *gobject_class)
  64 {
  65         parent_class = g_type_class_peek_parent (gobject_class);
  66
  67         gobject_class->finalize = gnm_py_interpreter_finalize;
  68
  69         signals[SET_CURRENT_SIGNAL] =
  70         g_signal_new (
  71                 "set_current",
  72                 G_TYPE_FROM_CLASS (gobject_class),
  73                 G_SIGNAL_RUN_FIRST,
  74                 G_STRUCT_OFFSET (GnmPyInterpreterClass, set_current),
  75                 NULL, NULL,
  76                 g_cclosure_marshal_VOID__VOID,
  77                 G_TYPE_NONE, 0);
  78 }
  79
  80 static char *plugin_argv[] = {(char *) "/dev/null/python/is/buggy/gnumeric", NULL};
  81
  82 GnmPyInterpreter *
  83 gnm_py_interpreter_new (GOPlugin *plugin)
  84 {
  85         GnmPyInterpreter *interpreter;
  86         PyThreadState *py_thread_state;
  87
  88         g_return_val_if_fail (plugin == NULL || GO_IS_PLUGIN (plugin), NULL);
  89
  90         if (plugin != NULL) {
  91                 py_thread_state = Py_NewInterpreter ();
  92         } else {
  93                 py_thread_state = PyThreadState_Get ();
  94         }
  95         g_return_val_if_fail (py_thread_state != NULL, NULL);
  96
  97         interpreter = g_object_new (GNM_PY_INTERPRETER_TYPE, NULL);
  98         interpreter->py_thread_state = py_thread_state;
  99         interpreter->plugin = plugin;
 100
 101         PySys_SetArgv (G_N_ELEMENTS (plugin_argv) - 1, plugin_argv);
 102         py_initgnumeric (interpreter);
 103
 104         return interpreter;
 105 }
 106
 107 void
 108 gnm_py_interpreter_destroy (GnmPyInterpreter *interpreter,
 109                             GnmPyInterpreter *new_interpreter)
 110 {
 111         g_return_if_fail (GNM_IS_PY_INTERPRETER (interpreter));
 112
 113         gnm_py_interpreter_switch_to (interpreter);
 114         Py_EndInterpreter (interpreter->py_thread_state);
 115         (void) PyThreadState_Swap (new_interpreter->py_thread_state);
 116         interpreter->py_thread_state = NULL;
 117         g_object_unref (interpreter);
 118 }
 119
 120 void
 121 gnm_py_interpreter_switch_to (GnmPyInterpreter *interpreter)
 122 {
 123         g_return_if_fail (GNM_IS_PY_INTERPRETER (interpreter));
 124
 125         if (PyThreadState_Get ()->interp != interpreter->py_thread_state->interp) {
 126                 (void) PyThreadState_Swap (interpreter->py_thread_state);
 127                 g_signal_emit (
 128                         interpreter, signals[SET_CURRENT_SIGNAL], 0);
 129         }
 130 }
 131
 132 static void
 133 run_print_string (const char *cmd, PyObject *stdout_obj)
 134 {
 135         PyObject *m, *d, *v;
 136         m = PyImport_AddModule ((char *) "__main__");
 137         if (m == NULL)
 138                 return;
 139         d = PyModule_GetDict (m);
 140         v = PyRun_String ((char *) cmd, Py_single_input, d, d);
 141         if (!v)
 142                 PyErr_Print ();
 143         if (Py_FlushLine () != 0)
 144                 PyErr_Clear ();
 145         if (v && v != Py_None && stdout_obj) {
 146                 if (PyFile_WriteObject (v, stdout_obj, Py_PRINT_RAW) != 0)
 147                         PyErr_Clear ();
 148         }
 149         if (v) {
 150                 Py_DECREF (v);
 151         }
 152 }
 153
 154 void
 155 gnm_py_interpreter_run_string (GnmPyInterpreter *interpreter, const char *cmd,
 156                                char **opt_stdout, char **opt_stderr)
 157 {
 158         PyObject *sys_module, *sys_module_dict;
 159         PyObject *saved_stdout_obj = NULL, *stdout_obj = NULL,
 160                  *saved_stderr_obj = NULL, *stderr_obj = NULL;
 161         PyObject *py_str;
 162
 163         g_return_if_fail (GNM_IS_PY_INTERPRETER (interpreter));
 164
 165         gnm_py_interpreter_switch_to (interpreter);
 166
 167         sys_module = PyImport_AddModule ((char *) "sys");
 168         if (sys_module == NULL)
 169                 PyErr_Print ();
 170         g_return_if_fail (sys_module != NULL);
 171         sys_module_dict = PyModule_GetDict (sys_module);
 172         g_return_if_fail (sys_module_dict != NULL);
 173         if (interpreter->stringio_class == NULL) {
 174                 PyObject *stringio_module, *stringio_module_dict;
 175
 176                 stringio_module = PyImport_ImportModule ((char *) "StringIO");
 177                 if (stringio_module == NULL)
 178                         PyErr_Print ();
 179                 g_return_if_fail (stringio_module != NULL);
 180                 stringio_module_dict = PyModule_GetDict (stringio_module);
 181                 g_return_if_fail (stringio_module_dict != NULL);
 182                 interpreter->stringio_class
 183                         = PyDict_GetItemString (stringio_module_dict,
 184                                                 (char *) "StringIO");
 185                 g_return_if_fail (interpreter->stringio_class != NULL);
 186                 Py_INCREF (interpreter->stringio_class);
 187         }
 188         if (opt_stdout != NULL) {
 189                 stdout_obj = PyInstance_New(interpreter->stringio_class,
 190                                             NULL, NULL);
 191                 if (stdout_obj == NULL)
 192                         PyErr_Print ();
 193                 g_return_if_fail (stdout_obj != NULL);
 194                 saved_stdout_obj = PyDict_GetItemString (sys_module_dict,
 195                                                          (char *) "stdout");
 196                 g_return_if_fail (saved_stdout_obj != NULL);
 197                 Py_INCREF (saved_stdout_obj);
 198                 PyDict_SetItemString (sys_module_dict, (char *) "stdout",
 199                                       stdout_obj);
 200         }
 201         if (opt_stderr != NULL) {
 202                 stderr_obj = PyInstance_New(interpreter->stringio_class,
 203                                             NULL, NULL);
 204                 if (stderr_obj == NULL)
 205                         PyErr_Print ();
 206                 g_return_if_fail (stderr_obj != NULL);
 207                 saved_stderr_obj = PyDict_GetItemString (sys_module_dict,
 208                                                          (char *) "stderr");
 209                 g_return_if_fail (saved_stderr_obj != NULL);
 210                 Py_INCREF (saved_stderr_obj);
 211                 PyDict_SetItemString (sys_module_dict, (char *) "stderr",
 212                                       stderr_obj);
 213         }
 214         run_print_string (cmd, stdout_obj);
 215         if (opt_stdout != NULL) {
 216                 PyDict_SetItemString (sys_module_dict, (char *) "stdout",
 217                                       saved_stdout_obj);
 218                 Py_DECREF (saved_stdout_obj);
 219                 py_str = PyObject_CallMethod (stdout_obj, (char *) "getvalue",
 220                                               NULL);
 221                 if (py_str && PyString_Check (py_str))
 222                         *opt_stdout = g_strdup (PyString_AsString (py_str));
 223                 else
 224                         *opt_stdout = NULL;
 225                 if (py_str == NULL)
 226                         PyErr_Print ();
 227                 Py_DECREF (stdout_obj);
 228         }
 229         if (opt_stderr != NULL) {
 230                 PyDict_SetItemString (sys_module_dict, (char *) "stderr",
 231                                       saved_stderr_obj);
 232                 Py_DECREF (saved_stderr_obj);
 233                 py_str = PyObject_CallMethod (stderr_obj, (char *) "getvalue",
 234                                               NULL);
 235                 if (py_str && PyString_Check (py_str))
 236                         *opt_stderr = g_strdup (PyString_AsString (py_str));
 237                 else
 238                         *opt_stderr = NULL;
 239                 if (py_str == NULL)
 240                         PyErr_Print ();
 241                 Py_DECREF (stderr_obj);
 242         }
 243 }
 244
 245 const char *
 246 gnm_py_interpreter_get_name (GnmPyInterpreter *interpreter)
 247 {
 248         g_return_val_if_fail (GNM_IS_PY_INTERPRETER (interpreter), NULL);
 249
 250         if (interpreter->plugin != NULL) {
 251                 return go_plugin_get_name (interpreter->plugin);
 252         } else {
 253                 return _("Default interpreter");
 254         }
 255 }
 256
 257 GOPlugin *
 258 gnm_py_interpreter_get_plugin (GnmPyInterpreter *interpreter)
 259 {
 260         g_return_val_if_fail (GNM_IS_PY_INTERPRETER (interpreter), NULL);
 261
 262         return interpreter->plugin;
 263 }
 264
 265 int
 266 gnm_py_interpreter_compare (gconstpointer a, gconstpointer b)
 267 {
 268         const GnmPyInterpreter *int_a = a, *int_b = b;
 269
 270         if (int_a->plugin == NULL && int_b->plugin == NULL) {
 271                 return 0;
 272         } else if (int_a->plugin == NULL) {
 273                 return -1;
 274         } else if (int_b->plugin == NULL) {
 275                 return 1;
 276         } else {
 277                 return g_utf8_collate (go_plugin_get_name (int_a->plugin),
 278                                        go_plugin_get_name (int_b->plugin));
 279         }
 280 }
 281
 282 GSF_DYNAMIC_CLASS (GnmPyInterpreter, gnm_py_interpreter,
 283         gnm_py_interpreter_class_init, gnm_py_interpreter_init,
 284         G_TYPE_OBJECT)