scripting.c

   1 /*
   2 Calf Box, an open source musical instrument.
   3 Copyright (C) 2010-2011 Krzysztof Foltman
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include "config.h"
  20
  21 #if USE_PYTHON
  22
  23 #include "app.h"
  24 #include "blob.h"
  25 #include "errors.h"
  26 #include "scripting.h"
  27 #include <assert.h>
  28 #include <glib.h>
  29 #include <Python.h>
  30
  31 struct PyCboxCallback
  32 {
  33     PyObject_HEAD
  34     struct cbox_command_target *target;
  35 };
  36
  37 static PyObject *
  38 PyCboxCallback_New(PyTypeObject *type, PyObject *args, PyObject *kwds)
  39 {
  40     struct PyCboxCallback *self;
  41
  42     self = (struct PyCboxCallback *)type->tp_alloc(type, 0);
  43     if (self != NULL) {
  44         self->target = NULL;
  45     }
  46
  47     return (PyObject *)self;
  48 }
  49
  50 static int
  51 PyCboxCallback_Init(struct PyCboxCallback *self, PyObject *args, PyObject *kwds)
  52 {
  53     PyObject *cobj = NULL;
  54     if (!PyArg_ParseTuple(args, "O!:init", &PyCapsule_Type, &cobj))
  55         return -1;
  56
  57     self->target = PyCapsule_GetPointer(cobj, NULL);
  58 }
  59
  60 static PyObject *cbox_python_do_cmd_on(struct cbox_command_target *ct, PyObject *self, PyObject *args);
  61
  62 static PyObject *
  63 PyCboxCallback_Call(PyObject *_self, PyObject *args, PyObject *kwds)
  64 {
  65     struct PyCboxCallback *self = (struct PyCboxCallback *)_self;
  66
  67     return cbox_python_do_cmd_on(self->target, _self, args);
  68 }
  69
  70 PyTypeObject CboxCallbackType = {
  71     PyObject_HEAD_INIT(NULL)
  72     .tp_name = "_cbox.Callback",
  73     .tp_basicsize = sizeof(struct PyCboxCallback),
  74     .tp_flags = Py_TPFLAGS_DEFAULT,
  75     .tp_doc = "Callback for feedback channel to Cbox C code",
  76     .tp_init = (initproc)PyCboxCallback_Init,
  77     .tp_new = PyCboxCallback_New,
  78     .tp_call = PyCboxCallback_Call
  79 };
  80
  81 static gboolean set_error_from_python(GError **error)
  82 {
  83     PyObject *ptype = NULL, *pvalue = NULL, *ptraceback = NULL;
  84     PyErr_Fetch(&ptype, &pvalue, &ptraceback);
  85     PyObject *ptypestr = PyObject_Str(ptype);
  86     PyObject *pvaluestr = PyObject_Str(pvalue);
  87     PyObject *ptypestr_unicode = PyUnicode_AsUTF8String(ptypestr);
  88     PyObject *pvaluestr_unicode = PyUnicode_AsUTF8String(pvaluestr);
  89     g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "%s: %s", PyBytes_AsString(ptypestr_unicode), PyBytes_AsString(pvaluestr_unicode));
  90     Py_DECREF(pvaluestr_unicode);
  91     Py_DECREF(ptypestr_unicode);
  92     //g_error("%s:%s", PyString_AsString(ptypestr), PyString_AsString(pvaluestr));
  93     Py_DECREF(ptypestr);
  94     Py_DECREF(pvaluestr);
  95     Py_DECREF(ptype);
  96     Py_XDECREF(pvalue);
  97     Py_XDECREF(ptraceback);
  98     return FALSE;
  99 }
 100
 101 static gboolean bridge_to_python_callback(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
 102 {
 103     PyObject *callback = ct->user_data;
 104
 105     int argc = strlen(cmd->arg_types);
 106     PyObject *arg_values = PyList_New(argc);
 107     for (int i = 0; i < argc; i++)
 108     {
 109         if (cmd->arg_types[i] == 's')
 110         {
 111             PyList_SetItem(arg_values, i, PyUnicode_FromString(cmd->arg_values[i]));
 112         }
 113         else
 114         if (cmd->arg_types[i] == 'o')
 115         {
 116             struct cbox_objhdr *oh = cmd->arg_values[i];
 117             char buf[40];
 118             uuid_unparse(oh->instance_uuid.uuid, buf);
 119             PyList_SetItem(arg_values, i, PyUnicode_FromString(buf));
 120         }
 121         else
 122         if (cmd->arg_types[i] == 'i')
 123         {
 124             PyList_SetItem(arg_values, i, PyLong_FromLong(*(int *)cmd->arg_values[i]));
 125         }
 126         else
 127         if (cmd->arg_types[i] == 'f')
 128         {
 129             PyList_SetItem(arg_values, i, PyFloat_FromDouble(*(double *)cmd->arg_values[i]));
 130         }
 131         else
 132         if (cmd->arg_types[i] == 'b')
 133         {
 134             struct cbox_blob *blob = cmd->arg_values[i];
 135             PyList_SetItem(arg_values, i, PyByteArray_FromStringAndSize(blob->data, blob->size));
 136         }
 137         else
 138         {
 139             PyList_SetItem(arg_values, i, Py_None);
 140             Py_INCREF(Py_None);
 141         }
 142     }
 143     struct PyCboxCallback *fbcb = NULL;
 144
 145     PyObject *args = PyTuple_New(3);
 146     PyTuple_SetItem(args, 0, PyUnicode_FromString(cmd->command));
 147     PyObject *pyfb = NULL;
 148     if (fb)
 149     {
 150         struct PyCboxCallback *fbcb = PyObject_New(struct PyCboxCallback, &CboxCallbackType);
 151         fbcb->target = fb;
 152         pyfb = (PyObject *)fbcb;
 153     }
 154     else
 155     {
 156         pyfb = Py_None;
 157         Py_INCREF(Py_None);
 158     }
 159     PyTuple_SetItem(args, 1, pyfb);
 160     PyTuple_SetItem(args, 2, arg_values);
 161
 162     PyObject *result = PyObject_Call(callback, args, NULL);
 163     Py_DECREF(args);
 164
 165     if (fbcb)
 166         fbcb->target = NULL;
 167
 168     if (result)
 169     {
 170         Py_DECREF(result);
 171         return TRUE;
 172     }
 173
 174     return set_error_from_python(error);
 175 }
 176
 177 static PyObject *cbox_python_do_cmd_on(struct cbox_command_target *ct, PyObject *self, PyObject *args)
 178 {
 179     const char *command = NULL;
 180     PyObject *callback = NULL;
 181     PyObject *list = NULL;
 182     if (!PyArg_ParseTuple(args, "sOO!:do_cmd", &command, &callback, &PyList_Type, &list))
 183         return NULL;
 184
 185     int len = PyList_Size(list);
 186     void *extra = malloc(len * sizeof(double));
 187     struct cbox_osc_command cmd;
 188     GError *error = NULL;
 189     char *arg_types = malloc(len + 1);
 190     void **arg_values = malloc(2 * len * sizeof(void *));
 191     void **arg_extra = &arg_values[len];
 192     cmd.command = command;
 193     cmd.arg_types = arg_types;
 194     cmd.arg_values = arg_values;
 195     double *arg_space = extra;
 196     gboolean free_blobs = FALSE;
 197     for (int i = 0; i < len; i++)
 198     {
 199         cmd.arg_values[i] = &arg_space[i];
 200         PyObject *value = PyList_GetItem(list, i);
 201
 202         if (PyLong_Check(value))
 203         {
 204             arg_types[i] = 'i';
 205             *(int *)arg_values[i] = PyLong_AsLong(value);
 206         }
 207         else
 208         if (PyFloat_Check(value))
 209         {
 210             arg_types[i] = 'f';
 211             *(double *)arg_values[i] = PyFloat_AsDouble(value);
 212         }
 213         else
 214         if (PyUnicode_Check(value))
 215         {
 216             PyObject *utf8str = PyUnicode_AsUTF8String(value);
 217             arg_types[i] = 's';
 218             arg_extra[i] = utf8str;
 219             arg_values[i] = PyBytes_AsString(utf8str);
 220         }
 221         else
 222         if (PyByteArray_Check(value))
 223         {
 224             const void *buf = PyByteArray_AsString(value);
 225             ssize_t len = PyByteArray_Size(value);
 226
 227             if (buf)
 228             {
 229                 // note: this is not really acquired, the blob is freed using free and not cbox_blob_destroy
 230                 struct cbox_blob *blob = cbox_blob_new_acquire_data((void *)buf, len);
 231                 arg_types[i] = 'b';
 232                 arg_values[i] = blob;
 233                 free_blobs = TRUE;
 234             }
 235             else
 236                 arg_types[i] = 'N';
 237         }
 238         else
 239         {
 240             PyObject *ob_type = (PyObject *)value->ob_type;
 241             PyObject *typename_unicode = PyObject_Str(ob_type);
 242             PyObject *typename_bytes = PyUnicode_AsUTF8String(typename_unicode);
 243             g_error("Cannot serialize Python type '%s'", PyBytes_AsString(typename_bytes));
 244             Py_DECREF(typename_bytes);
 245             Py_DECREF(typename_unicode);
 246
 247             assert(0);
 248         }
 249     }
 250     arg_types[len] = '\0';
 251
 252     struct cbox_command_target target;
 253     cbox_command_target_init(&target, bridge_to_python_callback, callback);
 254
 255     // cbox_osc_command_dump(&cmd);
 256     Py_INCREF(callback);
 257     gboolean result = ct->process_cmd(ct, callback != Py_None ? &target : NULL, &cmd, &error);
 258     Py_DECREF(callback);
 259
 260     if (free_blobs)
 261     {
 262         for (int i = 0; i < len; i++)
 263         {
 264             if (arg_types[i] == 'b')
 265                 free(arg_values[i]);
 266             if (arg_types[i] == 's')
 267                 Py_DECREF((PyObject *)arg_extra[i]);
 268         }
 269     }
 270     free(arg_space);
 271     free(arg_values);
 272     free(arg_types);
 273
 274     if (!result)
 275         return PyErr_Format(PyExc_Exception, "%s", error ? error->message : "Unknown error");
 276
 277     Py_RETURN_NONE;
 278 }
 279
 280 static PyObject *cbox_python_do_cmd(PyObject *self, PyObject *args)
 281 {
 282     return cbox_python_do_cmd_on(&app.cmd_target, self, args);
 283 }
 284
 285 static PyMethodDef CboxMethods[] = {
 286     {"do_cmd", cbox_python_do_cmd, METH_VARARGS, "Execute a CalfBox command using a global path."},
 287     {NULL, NULL, 0, NULL}
 288 };
 289
 290 static PyModuleDef CboxModule = {
 291     PyModuleDef_HEAD_INIT, "_cbox", NULL, -1, CboxMethods,
 292     NULL, NULL, NULL, NULL
 293 };
 294
 295 static PyObject*
 296 PyInit_cbox(void)
 297 {
 298     PyObject *m = PyModule_Create(&CboxModule);
 299     PyModule_AddObject(m, "Callback", (PyObject *)&CboxCallbackType);
 300     return m;
 301 }
 302
 303 void cbox_script_run(const char *name)
 304 {
 305     FILE *fp = fopen(name, "rb");
 306     if (!fp)
 307     {
 308         g_warning("Cannot open script file '%s': %s", name, strerror(errno));
 309         return;
 310     }
 311     PyImport_AppendInittab("_cbox", &PyInit_cbox);
 312     Py_Initialize();
 313     if (PyType_Ready(&CboxCallbackType) < 0)
 314     {
 315         g_warning("Cannot install the C callback type");
 316         return;
 317     }
 318     Py_INCREF(&CboxCallbackType);
 319
 320     if (PyRun_SimpleFile(fp, name) == 1)
 321     {
 322         GError *error = NULL;
 323         set_error_from_python(&error);
 324         cbox_print_error(error);
 325     }
 326     Py_Finalize();
 327 }
 328
 329 #endif