#include "libsigrokdecode.h"
#include <inttypes.h>
+/** @cond PRIVATE */
+extern SRD_PRIV GSList *sessions;
+/** @endcond */
+
typedef struct {
PyObject_HEAD
} srd_Decoder;
-/* This is only used for nicer srd_dbg() output.
- */
+/* This is only used for nicer srd_dbg() output. */
static const char *output_type_name(unsigned int idx)
{
static const char names[][16] = {
"OUTPUT_META",
"(invalid)"
};
+
return names[MIN(idx, G_N_ELEMENTS(names) - 1)];
}
+static void release_annotation(struct srd_proto_data_annotation *pda)
+{
+ if (!pda)
+ return;
+ if (pda->ann_text)
+ g_strfreev(pda->ann_text);
+ g_free(pda);
+}
+
static int convert_annotation(struct srd_decoder_inst *di, PyObject *obj,
struct srd_proto_data *pdata)
{
return SRD_ERR_PYTHON;
}
+static void release_binary(struct srd_proto_data_binary *pdb)
+{
+ if (!pdb)
+ return;
+ g_free((void *)pdb->data);
+ g_free(pdb);
+}
+
static int convert_binary(struct srd_decoder_inst *di, PyObject *obj,
struct srd_proto_data *pdata)
{
goto err;
}
- pdb = g_malloc(sizeof(struct srd_proto_data_binary));
if (PyBytes_AsStringAndSize(py_tmp, &buf, &size) == -1)
goto err;
PyGILState_Release(gstate);
+ pdb = g_malloc(sizeof(struct srd_proto_data_binary));
pdb->bin_class = bin_class;
pdb->size = size;
- if (!(pdb->data = g_try_malloc(pdb->size)))
+ if (!(pdb->data = g_try_malloc(pdb->size))) {
+ g_free(pdb);
return SRD_ERR_MALLOC;
+ }
memcpy((void *)pdb->data, (const void *)buf, pdb->size);
pdata->data = pdb;
return SRD_ERR_PYTHON;
}
+static inline struct srd_decoder_inst *srd_sess_inst_find_by_obj(
+ struct srd_session *sess, const GSList *stack, const PyObject *obj)
+{
+ const GSList *l;
+ struct srd_decoder_inst *tmp, *di;
+
+ if (!sess)
+ return NULL;
+
+ di = NULL;
+ for (l = stack ? stack : sess->di_list; di == NULL && l != NULL; l = l->next) {
+ tmp = l->data;
+ if (tmp->py_inst == obj)
+ di = tmp;
+ else if (tmp->next_di)
+ di = srd_sess_inst_find_by_obj(sess, tmp->next_di, obj);
+ }
+
+ return di;
+}
+
+/**
+ * Find a decoder instance by its Python object.
+ *
+ * I.e. find that instance's instantiation of the sigrokdecode.Decoder class.
+ * This will recurse to find the instance anywhere in the stack tree of all
+ * sessions.
+ *
+ * @param stack Pointer to a GSList of struct srd_decoder_inst, indicating the
+ * stack to search. To start searching at the bottom level of
+ * decoder instances, pass NULL.
+ * @param obj The Python class instantiation.
+ *
+ * @return Pointer to struct srd_decoder_inst, or NULL if not found.
+ *
+ * @since 0.1.0
+ */
+static inline struct srd_decoder_inst *srd_inst_find_by_obj(
+ const GSList *stack, const PyObject *obj)
+{
+ struct srd_decoder_inst *di;
+ struct srd_session *sess;
+ GSList *l;
+
+ di = NULL;
+ for (l = sessions; di == NULL && l != NULL; l = l->next) {
+ sess = l->data;
+ di = srd_sess_inst_find_by_obj(sess, stack, obj);
+ }
+
+ return di;
+}
+
static int convert_meta(struct srd_proto_data *pdata, PyObject *obj)
{
long long intvalue;
gstate = PyGILState_Ensure();
- if (pdata->pdo->meta_type == G_VARIANT_TYPE_INT64) {
+ if (g_variant_type_equal(pdata->pdo->meta_type, G_VARIANT_TYPE_INT64)) {
if (!PyLong_Check(obj)) {
PyErr_Format(PyExc_TypeError, "This output was registered "
"as 'int', but something else was passed.");
if (PyErr_Occurred())
goto err;
pdata->data = g_variant_new_int64(intvalue);
- } else if (pdata->pdo->meta_type == G_VARIANT_TYPE_DOUBLE) {
+ } else if (g_variant_type_equal(pdata->pdo->meta_type, G_VARIANT_TYPE_DOUBLE)) {
if (!PyFloat_Check(obj)) {
PyErr_Format(PyExc_TypeError, "This output was registered "
"as 'float', but something else was passed.");
return SRD_ERR_PYTHON;
}
+static void release_meta(GVariant *gvar)
+{
+ if (!gvar)
+ return;
+ g_variant_unref(gvar);
+}
+
static PyObject *Decoder_put(PyObject *self, PyObject *args)
{
GSList *l;
struct srd_pd_callback *cb;
PyGILState_STATE gstate;
+ py_data = NULL;
+
gstate = PyGILState_Ensure();
if (!(di = srd_inst_find_by_obj(NULL, self))) {
Py_BEGIN_ALLOW_THREADS
cb->cb(&pdata, cb->cb_data);
Py_END_ALLOW_THREADS
+ release_annotation(pdata.data);
}
break;
case SRD_OUTPUT_PYTHON:
Py_XDECREF(py_res);
}
if ((cb = srd_pd_output_callback_find(di->sess, pdo->output_type))) {
- /* Frontends aren't really supposed to get Python
- * callbacks, but it's useful for testing. */
+ /*
+ * Frontends aren't really supposed to get Python
+ * callbacks, but it's useful for testing.
+ */
pdata.data = py_data;
cb->cb(&pdata, cb->cb_data);
}
Py_BEGIN_ALLOW_THREADS
cb->cb(&pdata, cb->cb_data);
Py_END_ALLOW_THREADS
+ release_binary(pdata.data);
}
break;
case SRD_OUTPUT_META:
Py_BEGIN_ALLOW_THREADS
cb->cb(&pdata, cb->cb_data);
Py_END_ALLOW_THREADS
+ release_meta(pdata.data);
}
break;
default:
const GVariantType *meta_type_gv;
int output_type;
char *proto_id, *meta_name, *meta_descr;
- char *keywords[] = {"output_type", "proto_id", "meta", NULL};
+ char *keywords[] = { "output_type", "proto_id", "meta", NULL };
PyGILState_STATE gstate;
gboolean is_meta;
GSList *l;
goto err;
}
- /* Default to instance id, which defaults to class id. */
+ /* Default to instance ID, which defaults to class ID. */
proto_id = di->inst_id;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|s(Oss)", keywords,
&output_type, &proto_id,
}
}
- srd_dbg("Instance %s checking registration type %d for %s.",
- di->inst_id, output_type, proto_id);
pdo = NULL;
for (l = di->pd_output; l; l = l->next) {
cmp = l->data;
return SRD_TERM_EITHER_EDGE;
case 'n':
return SRD_TERM_NO_EDGE;
+ default:
+ return -1;
}
return -1;
PyObject *py_pinvalues;
PyGILState_STATE gstate;
- gstate = PyGILState_Ensure();
-
if (!di) {
srd_err("Invalid decoder instance.");
- PyGILState_Release(gstate);
return NULL;
}
+ gstate = PyGILState_Ensure();
+
py_pinvalues = PyTuple_New(di->dec_num_channels);
for (i = 0; i < di->dec_num_channels; i++) {
srd_err("Failed to get the value.");
goto err;
}
- term = g_malloc0(sizeof(struct srd_term));
+ term = g_malloc(sizeof(struct srd_term));
term->type = get_term_type(term_str);
term->channel = PyLong_AsLong(py_key);
g_free(term_str);
srd_err("Failed to get number of samples to skip.");
goto err;
}
- term = g_malloc0(sizeof(struct srd_term));
+ term = g_malloc(sizeof(struct srd_term));
term->type = SRD_TERM_SKIP;
term->num_samples_to_skip = num_samples_to_skip;
term->num_samples_already_skipped = 0;
GSList *term_list;
condition_list_free(di);
- term = g_malloc0(sizeof(*term));
+ term = g_malloc(sizeof(*term));
term->type = SRD_TERM_SKIP;
term->num_samples_to_skip = count;
term->num_samples_already_skipped = 0;
* while the termination request still gets signalled.
*/
found_match = FALSE;
- ret = process_samples_until_condition_match(di, &found_match);
+
+ /* Ignore return value for now, should never be negative. */
+ (void)process_samples_until_condition_match(di, &found_match);
Py_END_ALLOW_THREADS
}
static PyMethodDef Decoder_methods[] = {
- {"put", Decoder_put, METH_VARARGS,
- "Accepts a dictionary with the following keys: startsample, endsample, data"},
- {"register", (PyCFunction)Decoder_register, METH_VARARGS|METH_KEYWORDS,
- "Register a new output stream"},
- {"wait", Decoder_wait, METH_VARARGS,
- "Wait for one or more conditions to occur"},
- {"has_channel", Decoder_has_channel, METH_VARARGS,
- "Report whether a channel was supplied"},
+ { "put", Decoder_put, METH_VARARGS,
+ "Accepts a dictionary with the following keys: startsample, endsample, data" },
+ { "register", (PyCFunction)Decoder_register, METH_VARARGS|METH_KEYWORDS,
+ "Register a new output stream" },
+ { "wait", Decoder_wait, METH_VARARGS,
+ "Wait for one or more conditions to occur" },
+ { "has_channel", Decoder_has_channel, METH_VARARGS,
+ "Report whether a channel was supplied" },
{NULL, NULL, 0, NULL}
};
projects / libsigrokdecode.git / blobdiff