Various Python decoder infrastructure improvements.

 - Introduce 'struct sigrokdecode_decoder'.

 - Decoders are now handled via two C functions:
   - sigrokdecode_load_decoder(): Fills a 'struct sigrokdecode_decoder'.
   - sigrokdecode_run_decoder(): Runs a decoder function.

 - There are now two decoder API functions a script needs to implement:
   - register(): Returns a Python dict with certain metadata.
   - decode(): Runs the actual decoder code.

 - libsigrokdecode: Add and use some more #defines for errors:
   - SIGROKDECODE_ERR_ARGS
   - SIGROKDECODE_ERR_PYTHON

 - Various other smaller Python decode script infrastructure issues.

diff --git a/decode.c b/decode.c
index d87f5d282f4061dee3bae7a40844c6daea6df7a8..e6399db72ce346bf6d2dfc4e378a11ac0a2bcb4e 100644 (file)
--- a/decode.c
+++ b/decode.c
@@ -20,6 +20,7 @@
 
 #include <sigrokdecode.h> /* First, so we avoid a _POSIX_C_SOURCE warning. */
 #include <stdio.h>
+#include <string.h>
 
 /**
  * Initialize libsigrokdecode.
@@ -43,82 +44,174 @@ int sigrokdecode_init(void)
        return 0;
 }
 
+/**
+ * Helper function to handle Python strings.
+ *
+ * TODO: @param entries.
+ *
+ * @return 0 upon success, non-zero otherwise. The 'outstr' argument will
+ *         point to a malloc()ed string upon success.
+ */
+static int h_str(PyObject *py_res, PyObject *py_func, PyObject *py_mod,
+                const char *key, char **outstr)
+{
+       PyObject *py_str;
+       char *str;
+
+       py_str = PyMapping_GetItemString(py_res, (char *)key);
+       if (!py_str || !PyString_Check(py_str)) {
+               if (PyErr_Occurred())
+                       PyErr_Print();
+               Py_DECREF(py_func);
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
+       }
+
+       if (!(str = PyString_AsString(py_str))) {
+               if (PyErr_Occurred())
+                       PyErr_Print();
+               Py_DECREF(py_str);
+               Py_DECREF(py_func);
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
+       }
+
+       if (!(*outstr = strdup(str))) {
+               if (PyErr_Occurred())
+                       PyErr_Print();
+               Py_DECREF(py_str);
+               Py_DECREF(py_func);
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_MALLOC;
+       }
+
+       Py_DECREF(py_str);
+
+       return 0;
+}
+
 /**
  * TODO
  *
  * @param name TODO
  * @return 0 upon success, non-zero otherwise.
  */
-int sigrokdecode_load_decoder_file(const char *name)
+int sigrokdecode_load_decoder(const char *name,
+                             struct sigrokdecode_decoder **dec)
 {
-       /* QUICK HACK */
-       name = name;
+       struct sigrokdecode_decoder *d;
+       PyObject *py_name, *py_mod, *py_func, *py_res /* , *py_tuple */;
+       int r;
+
+       /* Get the name of the decoder module as Python string. */
+       if (!(py_name = PyString_FromString(name))) {
+               PyErr_Print();
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
+       }
+
+       /* "Import" the Python module. */
+       if (!(py_mod = PyImport_Import(py_name))) {
+               PyErr_Print();
+               Py_DECREF(py_name);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
+       }
+       Py_DECREF(py_name);
+
+       /* Get the 'register' function name as Python callable object. */
+       py_func = PyObject_GetAttrString(py_mod, "register");
+       if (!py_func || !PyCallable_Check(py_func)) {
+               if (PyErr_Occurred())
+                       PyErr_Print();
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
+       }
+
+       /* Call the 'register' function without arguments, get the result. */
+       if (!(py_res = PyObject_CallFunction(py_func, NULL))) {
+               PyErr_Print();
+               Py_DECREF(py_func);
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
+       }
+
+       if (!(d = malloc(sizeof(struct sigrokdecode_decoder))))
+               return SIGROKDECODE_ERR_MALLOC;
+
+       if ((r = h_str(py_res, py_func, py_mod, "id", &(d->id))) < 0)
+               return r;
+
+       if ((r = h_str(py_res, py_func, py_mod, "name", &(d->name))) < 0)
+               return r;
+
+       if ((r = h_str(py_res, py_func, py_mod, "desc", &(d->desc))) < 0)
+               return r;
+
+       d->py_mod = py_mod;
+
+       Py_DECREF(py_res);
+       Py_DECREF(py_func);
+
+       /* Get the 'decode' function name as Python callable object. */
+       py_func = PyObject_GetAttrString(py_mod, "decode");
+       if (!py_func || !PyCallable_Check(py_func)) {
+               if (PyErr_Occurred())
+                       PyErr_Print();
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
+       }
+
+       d->py_func = py_func;
+
+       /* TODO: Handle inputformats, outputformats. */
+
+       *dec = d;
 
-       /* TODO */
        return 0;
 }
 
 /**
  * Run the specified decoder function.
  *
- * @param decodername TODO
+ * @param dec TODO
  * @param inbuf TODO
  * @param inbuflen TODO
  * @param outbuf TODO
  * @param outbuflen TODO
  * @return 0 upon success, non-zero otherwise.
  */
-int sigrokdecode_run_decoder(const char *modulename, const char *decodername,
+int sigrokdecode_run_decoder(struct sigrokdecode_decoder *dec,
                             uint8_t *inbuf, uint64_t inbuflen,
                             uint8_t **outbuf, uint64_t *outbuflen)
 {
-       PyObject *py_name, *py_module, *py_func, *py_args;
-       PyObject *py_value, *py_result;
+       PyObject *py_mod, *py_func, *py_args, *py_value, *py_res;
        int ret;
 
        /* TODO: Use #defines for the return codes. */
 
        /* Return an error upon unusable input. */
-       if (decodername == NULL)
-               return -1;
+       if (dec == NULL)
+               return SIGROKDECODE_ERR_ARGS; /* TODO: More specific error? */
        if (inbuf == NULL)
-               return -2;
+               return SIGROKDECODE_ERR_ARGS; /* TODO: More specific error? */
        if (inbuflen == 0) /* No point in working on empty buffers. */
-               return -3;
+               return SIGROKDECODE_ERR_ARGS; /* TODO: More specific error? */
        if (outbuf == NULL)
-               return -4;
+               return SIGROKDECODE_ERR_ARGS; /* TODO: More specific error? */
        if (outbuflen == NULL)
-               return -5;
+               return SIGROKDECODE_ERR_ARGS; /* TODO: More specific error? */
 
-       /* Get the name of the decoder module/file as Python string. */
-       if (!(py_name = PyString_FromString(modulename))) {
-               PyErr_Print();
-               return -6;
-       }
+       /* TODO: Error handling. */
+       py_mod = dec->py_mod;
+       py_func = dec->py_func;
 
-       /* "Import" the python file/module. */
-       if (!(py_module = PyImport_Import(py_name))) {
-               PyErr_Print();
-               Py_DECREF(py_name);
-               return -7;
-       }
-       Py_DECREF(py_name);
-
-       /* Get the decoder/function name as Python callable object. */
-       py_func = PyObject_GetAttrString(py_module, decodername);
-       if (!py_func || !PyCallable_Check(py_func)) {
-               if (PyErr_Occurred())
-                       PyErr_Print();
-               Py_DECREF(py_module);
-               return -8;
-       }
+       /* TODO: Really run Py_DECREF on py_mod/py_func? */
 
        /* Create a Python tuple of size 1. */
        if (!(py_args = PyTuple_New(1))) {
                PyErr_Print();
                Py_DECREF(py_func);
-               Py_DECREF(py_module);
-               return -9;
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
        }
 
        /* Get the input buffer as Python "string" (byte array). */
@@ -127,8 +220,8 @@ int sigrokdecode_run_decoder(const char *modulename, const char *decodername,
                PyErr_Print();
                Py_DECREF(py_args);
                Py_DECREF(py_func);
-               Py_DECREF(py_module);
-               return -10;
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
        }
 
        if (PyTuple_SetItem(py_args, 0, py_value) != 0) {
@@ -136,35 +229,35 @@ int sigrokdecode_run_decoder(const char *modulename, const char *decodername,
                Py_DECREF(py_value);
                Py_DECREF(py_args);
                Py_DECREF(py_func);
-               Py_DECREF(py_module);
-               return -11;
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
        }
 
-       if (!(py_result = PyObject_CallObject(py_func, py_args))) {
+       if (!(py_res = PyObject_CallObject(py_func, py_args))) {
                PyErr_Print();
                Py_DECREF(py_value);
                Py_DECREF(py_args);
                Py_DECREF(py_func);
-               Py_DECREF(py_module);
-               return -12;
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
        }
 
-       if ((ret = PyObject_AsCharBuffer(py_result, (const char **)outbuf,
+       if ((ret = PyObject_AsCharBuffer(py_res, (const char **)outbuf,
                                         (Py_ssize_t *)outbuflen))) {
                PyErr_Print();
-               Py_DECREF(py_result);
+               Py_DECREF(py_res);
                Py_DECREF(py_value);
                Py_DECREF(py_args);
                Py_DECREF(py_func);
-               Py_DECREF(py_module);
-               return -13;
+               Py_DECREF(py_mod);
+               return SIGROKDECODE_ERR_PYTHON; /* TODO: More specific error? */
        }
 
-       Py_DECREF(py_result);
+       Py_DECREF(py_res);
        // Py_DECREF(py_value);
        Py_DECREF(py_args);
        Py_DECREF(py_func);
-       Py_DECREF(py_module);
+       Py_DECREF(py_mod);
 
        return 0;
 }

diff --git a/scripts/i2c.py b/scripts/i2c.py
index 0854895f0cf25b4446e0c40f007213c16e4400d2..602b01099401380fecb1838b7901cfc84a792cbc 100644 (file)
--- a/scripts/i2c.py
+++ b/scripts/i2c.py
@@ -68,7 +68,7 @@
 # TODO: Return two buffers, one with structured data for the GUI to parse
 #       and display, and one with human-readable ASCII output.
 
-def sigrokdecode_i2c(inbuf):
+def decode(inbuf):
        """I2C protocol decoder"""
 
        # FIXME: This should be passed in as metadata, not hardcoded here.
@@ -153,20 +153,20 @@ def register():
        return {
                'id': 'i2c',
                'name': 'I2C',
-               'description': 'Inter-Integrated Circuit (I2C) bus',
-               'function': 'sigrokdecode_i2c',
+               'desc': 'Inter-Integrated Circuit (I2C) bus',
+               'func': 'decode',
                'inputformats': ['raw'],
                'signalnames':  {
                                'SCL': 'Serial clock line',
                                'SDA': 'Serial data line',
                                },
-               'ouputformats': ['i2c', 'ascii'],
+               'outputformats': ['i2c', 'ascii'],
        }
 
 # Use psyco (if available) as it results in huge performance improvements.
 try:
        import psyco
-       psyco.bind(sigrokdecode_i2c)
+       psyco.bind(decode)
 except ImportError:
        pass
 

diff --git a/scripts/transitioncounter.py b/scripts/transitioncounter.py
index a9e83f774b18d0d00ce01c460d9829b18e78e7c8..4064d2f5debc71da5dd732d3afd6f20d418a09c6 100644 (file)
--- a/scripts/transitioncounter.py
+++ b/scripts/transitioncounter.py
@@ -18,7 +18,7 @@
 ## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 ##
 
-def sigrokdecode_count_transitions(inbuf):
+def decode(inbuf):
        """Counts the low->high and high->low transitions in the specified
           channel(s) of the signal."""
 
@@ -81,8 +81,8 @@ def register():
        return {
                'id': 'transitioncounter',
                'name': 'Transition counter',
-               'description': 'TODO',
-               'function': 'sigrokdecode_count_transitions',
+               'desc': 'TODO',
+               'func': 'decode',
                'inputformats': ['raw'],
                'signalnames': {}, # FIXME
                'outputformats': ['transitioncounts'],
@@ -91,7 +91,7 @@ def register():
 # Use psyco (if available) as it results in huge performance improvements.
 try:
        import psyco
-       psyco.bind(sigrokdecode_count_transitions)
+       psyco.bind(decode)
 except ImportError:
        pass
 

diff --git a/sigrokdecode.h b/sigrokdecode.h
index be3ab98e05d9929bf2b2864c29f5508557c40f57..5112e0969e23ebe16995aa3d90bc1794e9de03c8 100644 (file)
--- a/sigrokdecode.h
+++ b/sigrokdecode.h
@@ -23,6 +23,7 @@
 
 #include <Python.h> /* First, so we avoid a _POSIX_C_SOURCE warning. */
 #include <stdint.h>
+#include <glib.h>
 
 /*
  * Status/error codes returned by libsigrokdecode functions.
@@ -44,20 +45,25 @@
 #define SIGROKDECODE_OK                         0 /* No error */
 #define SIGROKDECODE_ERR               -1 /* Generic/unspecified error */
 #define SIGROKDECODE_ERR_MALLOC                -2 /* Malloc/calloc/realloc error */
+#define SIGROKDECODE_ERR_ARGS          -3 /* Function argument error */
+#define SIGROKDECODE_ERR_PYTHON                -4 /* Python C API error */
 
 /* TODO: Documentation. */
-struct sigrokdecode_decoder_info {
+struct sigrokdecode_decoder {
        char *id;
        char *name;
-       char *description;
-       char *function;
-       char *inputformats; /* FIXME: Should be a list. */
-       char *outputformats; /* FIXME: Should be a list. */
+       char *desc;
+       char *func;
+       GSList *inputformats;
+       GSList *outputformats;
+
+       PyObject *py_mod;
+       PyObject *py_func;
 };
 
 int sigrokdecode_init(void);
-int sigrokdecode_load_decoder_file(const char *name);
-int sigrokdecode_run_decoder(const char *modulename, const char *decodername,
+int sigrokdecode_load_decoder(const char *name, struct sigrokdecode_decoder **dec);
+int sigrokdecode_run_decoder(struct sigrokdecode_decoder *dec,
                             uint8_t *inbuf, uint64_t inbuflen,
                             uint8_t **outbuf, uint64_t *outbuflen);
 int sigrokdecode_shutdown(void);