decoder: don't break error messages, factor out Python variable name

[libsigrokdecode.git] / decoder.c

diff --git a/decoder.c b/decoder.c
index fc6ae07317c86929a8db634c9b9d2e4391dba081..3e047221e844f67fd74856410d8d2670389b3094 100644 (file)
--- a/decoder.c
+++ b/decoder.c
@@ -136,6 +136,18 @@ static void annotation_row_free(void *data)
        g_free(row);
 }
 
+static void logic_output_channel_free(void *data)
+{
+       struct srd_decoder_logic_output_channel *logic_out_ch = data;
+
+       if (!logic_out_ch)
+               return;
+
+       g_free(logic_out_ch->desc);
+       g_free(logic_out_ch->id);
+       g_free(logic_out_ch);
+}
+
 static void decoder_option_free(void *data)
 {
        struct srd_decoder_option *opt = data;
@@ -401,8 +413,8 @@ static int get_annotations(struct srd_decoder *dec)
                goto except_out;
 
        if (!PyTuple_Check(py_annlist)) {
-               srd_err("Protocol decoder %s annotations should "
-                       "be a tuple.", dec->name);
+               srd_err("Protocol decoder %s annotations should be a tuple.",
+                       dec->name);
                goto err_out;
        }
 
@@ -412,8 +424,7 @@ static int get_annotations(struct srd_decoder *dec)
                        goto except_out;
 
                if (!PyTuple_Check(py_ann) || PyTuple_Size(py_ann) != 2) {
-                       srd_err("Protocol decoder %s annotation %zd should "
-                               "be a tuple with two elements.",
+                       srd_err("Protocol decoder %s annotation %zd should be a tuple with two elements.",
                                dec->name, i + 1);
                        goto err_out;
                }
@@ -442,6 +453,8 @@ err_out:
 /* Convert annotation_rows to GSList of 'struct srd_decoder_annotation_row'. */
 static int get_annotation_rows(struct srd_decoder *dec)
 {
+       const char *py_member_name = "annotation_rows";
+
        PyObject *py_ann_rows, *py_ann_row, *py_ann_classes, *py_item;
        GSList *annotation_rows;
        struct srd_decoder_annotation_row *ann_row;
@@ -451,20 +464,20 @@ static int get_annotation_rows(struct srd_decoder *dec)
 
        gstate = PyGILState_Ensure();
 
-       if (!PyObject_HasAttrString(dec->py_dec, "annotation_rows")) {
+       if (!PyObject_HasAttrString(dec->py_dec, py_member_name)) {
                PyGILState_Release(gstate);
                return SRD_OK;
        }
 
        annotation_rows = NULL;
 
-       py_ann_rows = PyObject_GetAttrString(dec->py_dec, "annotation_rows");
+       py_ann_rows = PyObject_GetAttrString(dec->py_dec, py_member_name);
        if (!py_ann_rows)
                goto except_out;
 
        if (!PyTuple_Check(py_ann_rows)) {
-               srd_err("Protocol decoder %s annotation_rows "
-                       "must be a tuple.", dec->name);
+               srd_err("Protocol decoder %s %s must be a tuple.",
+                       dec->name, py_member_name);
                goto err_out;
        }
 
@@ -474,9 +487,8 @@ static int get_annotation_rows(struct srd_decoder *dec)
                        goto except_out;
 
                if (!PyTuple_Check(py_ann_row) || PyTuple_Size(py_ann_row) != 3) {
-                       srd_err("Protocol decoder %s annotation_rows "
-                               "must contain only tuples of 3 elements.",
-                               dec->name);
+                       srd_err("Protocol decoder %s %s must contain only tuples of 3 elements.",
+                               dec->name, py_member_name);
                        goto err_out;
                }
                ann_row = g_malloc0(sizeof(struct srd_decoder_annotation_row));
@@ -500,9 +512,8 @@ static int get_annotation_rows(struct srd_decoder *dec)
                        goto except_out;
 
                if (!PyTuple_Check(py_ann_classes)) {
-                       srd_err("Protocol decoder %s annotation_rows tuples "
-                               "must have a tuple of numbers as 3rd element.",
-                               dec->name);
+                       srd_err("Protocol decoder %s %s tuples must have a tuple of numbers as 3rd element.",
+                               dec->name, py_member_name);
                        goto err_out;
                }
 
@@ -512,8 +523,7 @@ static int get_annotation_rows(struct srd_decoder *dec)
                                goto except_out;
 
                        if (!PyLong_Check(py_item)) {
-                               srd_err("Protocol decoder %s annotation row "
-                                       "class tuple must only contain numbers.",
+                               srd_err("Protocol decoder %s annotation row class tuple must only contain numbers.",
                                        dec->name);
                                goto err_out;
                        }
@@ -606,6 +616,79 @@ err_out:
        return SRD_ERR_PYTHON;
 }
 
+/* Convert logic_output_channels to GSList of 'struct srd_decoder_logic_output_channel'. */
+static int get_logic_output_channels(struct srd_decoder *dec)
+{
+       PyObject *py_logic_out_chs, *py_logic_out_ch, *py_item;
+       GSList *logic_out_chs;
+       struct srd_decoder_logic_output_channel *logic_out_ch;
+       ssize_t i;
+       PyGILState_STATE gstate;
+
+       gstate = PyGILState_Ensure();
+
+       if (!PyObject_HasAttrString(dec->py_dec, "logic_output_channels")) {
+               PyGILState_Release(gstate);
+               return SRD_OK;
+       }
+
+       logic_out_chs = NULL;
+
+       py_logic_out_chs = PyObject_GetAttrString(dec->py_dec, "logic_output_channels");
+       if (!py_logic_out_chs)
+               goto except_out;
+
+       if (!PyTuple_Check(py_logic_out_chs)) {
+               srd_err("Protocol decoder %s logic_output_channels "
+                       "must be a tuple.", dec->name);
+               goto err_out;
+       }
+
+       for (i = PyTuple_Size(py_logic_out_chs) - 1; i >= 0; i--) {
+               py_logic_out_ch = PyTuple_GetItem(py_logic_out_chs, i);
+               if (!py_logic_out_ch)
+                       goto except_out;
+
+               if (!PyTuple_Check(py_logic_out_ch) || PyTuple_Size(py_logic_out_ch) != 2) {
+                       srd_err("Protocol decoder %s logic_output_channels "
+                               "must contain only tuples of 2 elements.",
+                               dec->name);
+                       goto err_out;
+               }
+               logic_out_ch = g_malloc0(sizeof(*logic_out_ch));
+               /* Add to list right away so it doesn't get lost. */
+               logic_out_chs = g_slist_prepend(logic_out_chs, logic_out_ch);
+
+               py_item = PyTuple_GetItem(py_logic_out_ch, 0);
+               if (!py_item)
+                       goto except_out;
+               if (py_str_as_str(py_item, &logic_out_ch->id) != SRD_OK)
+                       goto err_out;
+
+               py_item = PyTuple_GetItem(py_logic_out_ch, 1);
+               if (!py_item)
+                       goto except_out;
+               if (py_str_as_str(py_item, &logic_out_ch->desc) != SRD_OK)
+                       goto err_out;
+       }
+       dec->logic_output_channels = logic_out_chs;
+       Py_DECREF(py_logic_out_chs);
+       PyGILState_Release(gstate);
+
+       return SRD_OK;
+
+except_out:
+       srd_exception_catch("Failed to get %s decoder logic output channels",
+                       dec->name);
+
+err_out:
+       g_slist_free_full(logic_out_chs, &logic_output_channel_free);
+       Py_XDECREF(py_logic_out_chs);
+       PyGILState_Release(gstate);
+
+       return SRD_ERR_PYTHON;
+}
+
 /* Check whether the Decoder class defines the named method. */
 static int check_method(PyObject *py_dec, const char *mod_name,
                const char *method_name)
@@ -944,6 +1027,11 @@ SRD_API int srd_decoder_load(const char *module_name)
                goto err_out;
        }
 
+       if (get_logic_output_channels(d) != SRD_OK) {
+               fail_txt = "cannot get logic output channels";
+               goto err_out;
+       }
+
        PyGILState_Release(gstate);
 
        /* Append it to the list of loaded decoders. */