comparison native/PyPluginObject.cpp @ 112:9343eee50605

Update to Python 3. Currently crashes during tests (and also, two tests are now failing, even with Py2).

 
 #include "structmember.h"
 
 #include "FloatConversion.h"
 #include "VectorConversion.h"
+#include "StringConversion.h"
 #include "PyRealTime.h"
 
 #include <string>
 #include <vector>
 #include <cstddef>

                         "Invalid or already deleted plugin handle.");
         return 0;
     } else {
         return pd;
     }
-}
-
-static
-PyObject *
-pystr(const string &s)
-{
-#if PY_MAJOR_VERSION < 3
-    return PyString_FromString(s.c_str());
-#else
-    return PyUnicode_FromString(s.c_str());
-#endif
-}
-
-static
-string
-py2str(PyObject *obj)
-{
-#if PY_MAJOR_VERSION < 3
-    return PyString_AsString(obj);
-#else
-    return PyBytes_AsString(PyUnicode_AsUTF8String(obj));
-#endif
 }
 
 PyObject *
 PyPluginObject_From_Plugin(Plugin *plugin)
 {

     pd->isInitialised = false;
     pd->channels = 0;
     pd->blockSize = 0;
     pd->stepSize = 0;
 
+    StringConversion strconv;
+    
     PyObject *infodict = PyDict_New();
     PyDict_SetItemString
         (infodict, "apiVersion", PyLong_FromLong(plugin->getVampApiVersion()));
     PyDict_SetItemString
         (infodict, "pluginVersion", PyLong_FromLong(plugin->getPluginVersion()));
     PyDict_SetItemString
-        (infodict, "identifier", pystr(plugin->getIdentifier()));
-    PyDict_SetItemString
-        (infodict, "name", pystr(plugin->getName()));
-    PyDict_SetItemString
-        (infodict, "description", pystr(plugin->getDescription()));
-    PyDict_SetItemString
-        (infodict, "maker", pystr(plugin->getMaker()));
-    PyDict_SetItemString
-        (infodict, "copyright", pystr(plugin->getCopyright()));
+        (infodict, "identifier", strconv.string2py(plugin->getIdentifier()));
+    PyDict_SetItemString
+        (infodict, "name", strconv.string2py(plugin->getName()));
+    PyDict_SetItemString
+        (infodict, "description", strconv.string2py(plugin->getDescription()));
+    PyDict_SetItemString
+        (infodict, "maker", strconv.string2py(plugin->getMaker()));
+    PyDict_SetItemString
+        (infodict, "copyright", strconv.string2py(plugin->getCopyright()));
     pd->info = infodict;
 
     pd->inputDomain = plugin->getInputDomain();
 
     VectorConversion conv;

     PyObject *params = PyList_New(pl.size());
     
     for (int i = 0; i < (int)pl.size(); ++i) {
         PyObject *paramdict = PyDict_New();
         PyDict_SetItemString
-            (paramdict, "identifier", pystr(pl[i].identifier));
+            (paramdict, "identifier", strconv.string2py(pl[i].identifier));
         PyDict_SetItemString
-            (paramdict, "name", pystr(pl[i].name));
+            (paramdict, "name", strconv.string2py(pl[i].name));
         PyDict_SetItemString
-            (paramdict, "description", pystr(pl[i].description));
+            (paramdict, "description", strconv.string2py(pl[i].description));
         PyDict_SetItemString
-            (paramdict, "unit", pystr(pl[i].unit));
+            (paramdict, "unit", strconv.string2py(pl[i].unit));
         PyDict_SetItemString
             (paramdict, "minValue", PyFloat_FromDouble(pl[i].minValue));
         PyDict_SetItemString
             (paramdict, "maxValue", PyFloat_FromDouble(pl[i].maxValue));
         PyDict_SetItemString

 
     Plugin::ProgramList prl = plugin->getPrograms();
     PyObject *progs = PyList_New(prl.size());
 
     for (int i = 0; i < (int)prl.size(); ++i) {
-        PyList_SET_ITEM(progs, i, pystr(prl[i]));
+        PyList_SET_ITEM(progs, i, strconv.string2py(prl[i]));
     }
 
     pd->programs = progs;
     
     return (PyObject *)pd;

 
 static PyObject *
 convertOutput(const Plugin::OutputDescriptor &desc, int ix)
 {
     VectorConversion conv;
+    StringConversion strconv;
     
     PyObject *outdict = PyDict_New();
     PyDict_SetItemString
-        (outdict, "identifier", pystr(desc.identifier));
-    PyDict_SetItemString
-        (outdict, "name", pystr(desc.name));
-    PyDict_SetItemString
-        (outdict, "description", pystr(desc.description));
-    PyDict_SetItemString
-        (outdict, "unit", pystr(desc.unit));
+        (outdict, "identifier", strconv.string2py(desc.identifier));
+    PyDict_SetItemString
+        (outdict, "name", strconv.string2py(desc.name));
+    PyDict_SetItemString
+        (outdict, "description", strconv.string2py(desc.description));
+    PyDict_SetItemString
+        (outdict, "unit", strconv.string2py(desc.unit));
     PyDict_SetItemString
         (outdict, "hasFixedBinCount", PyLong_FromLong(desc.hasFixedBinCount));
     if (desc.hasFixedBinCount) {
         PyDict_SetItemString
             (outdict, "binCount", PyLong_FromLong(desc.binCount));

 get_output(PyObject *self, PyObject *args)
 {
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
-    int n = -1;
+    ssize_t n = -1;
     PyObject *pyId = 0;
     
     if (!PyArg_ParseTuple(args, "n", &n) &&
-        !PyArg_ParseTuple(args, "S", &pyId)) {
+        !PyArg_ParseTuple(args,
+#if (PY_MAJOR_VERSION >= 3)
+                          "U",
+#else
+                          "S",
+#endif
+                          &pyId)) {
         PyErr_SetString(PyExc_TypeError,
                         "get_output takes either output id (string) or output index (int) argument");
         return 0;
     }
 
     PyErr_Clear();
     
     Plugin::OutputList ol = pd->plugin->getOutputDescriptors();
 
+    StringConversion strconv;
+    
     if (pyId) {
-        string id = py2str(pyId);
+        string id = strconv.py2string(pyId);
         for (int i = 0; i < int(ol.size()); ++i) {
             if (ol[i].identifier == id) {
                 return convertOutput(ol[i], i);
             }
         }

 }
 
 static PyObject *
 initialise(PyObject *self, PyObject *args)
 {
-    size_t channels, blockSize, stepSize;
+    ssize_t channels, blockSize, stepSize;
 
     if (!PyArg_ParseTuple (args, "nnn",
-                           (size_t) &channels,
-                           (size_t) &stepSize,
-                           (size_t) &blockSize)) {
+                           &channels,
+                           &stepSize,
+                           &blockSize)) {
         PyErr_SetString(PyExc_TypeError,
                         "initialise() takes channel count, step size, and block size arguments");
         return 0;
     }
 

 static PyObject *
 get_parameter_value(PyObject *self, PyObject *args)
 {
     PyObject *pyParam;
 
-    if (!PyArg_ParseTuple(args, "S", &pyParam)) {
+    if (!PyArg_ParseTuple(args,
+#if (PY_MAJOR_VERSION >= 3)
+                          "U",
+#else
+                          "S",
+#endif
+                          &pyParam)) {
         PyErr_SetString(PyExc_TypeError,
                         "get_parameter_value() takes parameter id (string) argument");
         return 0; }
 
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
-    string param = py2str(pyParam);
+    StringConversion strconv;
+    
+    string param = strconv.py2string(pyParam);
     
     if (!hasParameter(pd, param)) {
         PyErr_SetString(PyExc_Exception,
                         (string("Unknown parameter id \"") + param + "\"").c_str());
         return 0;

 set_parameter_value(PyObject *self, PyObject *args)
 {
     PyObject *pyParam;
     float value;
 
-    if (!PyArg_ParseTuple(args, "Sf", &pyParam, &value)) {
+    if (!PyArg_ParseTuple(args,
+#if (PY_MAJOR_VERSION >= 3)
+                          "Uf",
+#else
+                          "Sf",
+#endif
+                          &pyParam, &value)) {
         PyErr_SetString(PyExc_TypeError,
                         "set_parameter_value() takes parameter id (string), and value (float) arguments");
         return 0; }
 
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
-    string param = py2str(pyParam);
+    StringConversion strconv;
+    
+    string param = strconv.py2string(pyParam);
     
     if (!hasParameter(pd, param)) {
         PyErr_SetString(PyExc_Exception,
                         (string("Unknown parameter id \"") + param + "\"").c_str());
         return 0;

         if (!value || !FloatConversion::check(value)) {
             PyErr_SetString(PyExc_TypeError,
                             "Parameter dict values must be convertible to float");
             return 0;
         }
-        string param = py2str(key);
+        StringConversion strconv;
+        string param = strconv.py2string(key);
         if (paramIds.find(param) == paramIds.end()) {
             PyErr_SetString(PyExc_Exception,
                             (string("Unknown parameter id \"") + param + "\"").c_str());
             return 0;
         }

 static PyObject *
 select_program(PyObject *self, PyObject *args)
 {
     PyObject *pyParam;
 
-    if (!PyArg_ParseTuple(args, "S", &pyParam)) {
+    if (!PyArg_ParseTuple(args,
+#if (PY_MAJOR_VERSION >= 3)
+                          "U",
+#else
+                          "S",
+#endif
+                          &pyParam)) {
         PyErr_SetString(PyExc_TypeError,
                         "select_program() takes parameter id (string) argument");
         return 0; }
 
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
-    pd->plugin->selectProgram(py2str(pyParam));
+    StringConversion strconv;
+    
+    pd->plugin->selectProgram(strconv.py2string(pyParam));
     return Py_True;
 }
 
 static
 PyObject *

                 if (f.hasDuration) {
                     PyDict_SetItemString
                         (pyF, "duration", PyRealTime_FromRealTime(f.duration));
                 }
 
+                StringConversion strconv;
+    
                 PyDict_SetItemString
-                    (pyF, "label", pystr(f.label));
+                    (pyF, "label", strconv.string2py(f.label));
 
                 if (!f.values.empty()) {
                     PyDict_SetItemString
                         (pyF, "values", conv.PyArray_From_FloatVector(f.values));
                 }

 };
 
 /* Doc:: 10.3 Type Objects */ /* static */ 
 PyTypeObject Plugin_Type = 
 {
-    PyObject_HEAD_INIT(NULL)
-    0,                                  /*ob_size*/
+    PyVarObject_HEAD_INIT(NULL, 0)
     "vampyhost.Plugin",                 /*tp_name*/
     sizeof(PyPluginObject),             /*tp_basicsize*/
     0,                                  /*tp_itemsize*/
     (destructor)PyPluginObject_dealloc, /*tp_dealloc*/
     0,                                  /*tp_print*/