X-Git-Url: https://sigrok.org/gitweb/?p=libsigrokdecode.git;a=blobdiff_plain;f=type_decoder.c;h=c097c7fce5b94cb950d3cb03c0fb4e52371a0df2;hp=59fb0498b08d616275b5f3cc5cd03e14e1d45e83;hb=HEAD;hpb=996b17db506ceb435ae3ed53d4c6ac66e10c7b34 diff --git a/type_decoder.c b/type_decoder.c index 59fb049..6932cde 100644 --- a/type_decoder.c +++ b/type_decoder.c @@ -31,12 +31,13 @@ typedef struct { } srd_Decoder; /* This is only used for nicer srd_dbg() output. */ -static const char *output_type_name(unsigned int idx) +SRD_PRIV const char *output_type_name(unsigned int idx) { - static const char names[][16] = { + static const char *names[] = { "OUTPUT_ANN", "OUTPUT_PYTHON", "OUTPUT_BINARY", + "OUTPUT_LOGIC", "OUTPUT_META", "(invalid)" }; @@ -50,7 +51,6 @@ static void release_annotation(struct srd_proto_data_annotation *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, @@ -67,16 +67,16 @@ static int convert_annotation(struct srd_decoder_inst *di, PyObject *obj, /* Should be a list of [annotation class, [string, ...]]. */ if (!PyList_Check(obj)) { - srd_err("Protocol decoder %s submitted an annotation that" - " is not a list", di->decoder->name); + srd_err("Protocol decoder %s submitted an annotation that is not a list", + di->decoder->name); goto err; } /* Should have 2 elements. */ if (PyList_Size(obj) != 2) { - srd_err("Protocol decoder %s submitted annotation list with " - "%zd elements instead of 2", di->decoder->name, - PyList_Size(obj)); + ssize_t sz = PyList_Size(obj); + srd_err("Protocol decoder %s submitted annotation list with %zd elements instead of 2", + di->decoder->name, sz); goto err; } @@ -86,34 +86,33 @@ static int convert_annotation(struct srd_decoder_inst *di, PyObject *obj, */ py_tmp = PyList_GetItem(obj, 0); if (!PyLong_Check(py_tmp)) { - srd_err("Protocol decoder %s submitted annotation list, but " - "first element was not an integer.", di->decoder->name); + srd_err("Protocol decoder %s submitted annotation list, but first element was not an integer.", + di->decoder->name); goto err; } ann_class = PyLong_AsLong(py_tmp); if (!(pdo = g_slist_nth_data(di->decoder->annotations, ann_class))) { - srd_err("Protocol decoder %s submitted data to unregistered " - "annotation class %d.", di->decoder->name, ann_class); + srd_err("Protocol decoder %s submitted data to unregistered annotation class %d.", + di->decoder->name, ann_class); goto err; } /* Second element must be a list. */ py_tmp = PyList_GetItem(obj, 1); if (!PyList_Check(py_tmp)) { - srd_err("Protocol decoder %s submitted annotation list, but " - "second element was not a list.", di->decoder->name); + srd_err("Protocol decoder %s submitted annotation list, but second element was not a list.", + di->decoder->name); goto err; } if (py_strseq_to_char(py_tmp, &ann_text) != SRD_OK) { - srd_err("Protocol decoder %s submitted annotation list, but " - "second element was malformed.", di->decoder->name); + srd_err("Protocol decoder %s submitted annotation list, but second element was malformed.", + di->decoder->name); goto err; } - pda = g_malloc(sizeof(struct srd_proto_data_annotation)); + pda = pdata->data; pda->ann_class = ann_class; pda->ann_text = ann_text; - pdata->data = pda; PyGILState_Release(gstate); @@ -125,12 +124,94 @@ err: return SRD_ERR_PYTHON; } +static void release_logic(struct srd_proto_data_logic *pdl) +{ + if (!pdl) + return; + g_free((void *)pdl->data); +} + +static int convert_logic(struct srd_decoder_inst *di, PyObject *obj, + struct srd_proto_data *pdata) +{ + struct srd_proto_data_logic *pdl; + PyObject *py_tmp; + Py_ssize_t size; + int logic_group; + char *group_name, *buf; + PyGILState_STATE gstate; + + gstate = PyGILState_Ensure(); + + /* Should be a list of [logic group, bytes]. */ + if (!PyList_Check(obj)) { + srd_err("Protocol decoder %s submitted non-list for SRD_OUTPUT_LOGIC.", + di->decoder->name); + goto err; + } + + /* Should have 2 elements. */ + if (PyList_Size(obj) != 2) { + srd_err("Protocol decoder %s submitted SRD_OUTPUT_LOGIC list " + "with %zd elements instead of 2", di->decoder->name, + PyList_Size(obj)); + goto err; + } + + /* The first element should be an integer. */ + py_tmp = PyList_GetItem(obj, 0); + if (!PyLong_Check(py_tmp)) { + srd_err("Protocol decoder %s submitted SRD_OUTPUT_LOGIC list, " + "but first element was not an integer.", di->decoder->name); + goto err; + } + logic_group = PyLong_AsLong(py_tmp); + if (!(group_name = g_slist_nth_data(di->decoder->logic_output_channels, logic_group))) { + srd_err("Protocol decoder %s submitted SRD_OUTPUT_LOGIC with " + "unregistered logic group %d.", di->decoder->name, logic_group); + goto err; + } + + /* Second element should be bytes. */ + py_tmp = PyList_GetItem(obj, 1); + if (!PyBytes_Check(py_tmp)) { + srd_err("Protocol decoder %s submitted SRD_OUTPUT_LOGIC list, " + "but second element was not bytes.", di->decoder->name); + goto err; + } + + /* Consider an empty set of bytes a bug. */ + if (PyBytes_Size(py_tmp) == 0) { + srd_err("Protocol decoder %s submitted SRD_OUTPUT_LOGIC " + "with empty data set.", di->decoder->name); + goto err; + } + + if (PyBytes_AsStringAndSize(py_tmp, &buf, &size) == -1) + goto err; + + PyGILState_Release(gstate); + + pdl = pdata->data; + pdl->logic_group = logic_group; + /* pdl->repeat_count is set by the caller as it depends on the sample range */ + if (!(pdl->data = g_try_malloc(size))) + return SRD_ERR_MALLOC; + memcpy((void *)pdl->data, (const void *)buf, size); + + return SRD_OK; + +err: + PyGILState_Release(gstate); + + 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, @@ -154,38 +235,38 @@ static int convert_binary(struct srd_decoder_inst *di, PyObject *obj, /* Should have 2 elements. */ if (PyList_Size(obj) != 2) { - srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY list " - "with %zd elements instead of 2", di->decoder->name, - PyList_Size(obj)); + ssize_t sz = PyList_Size(obj); + srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY list with %zd elements instead of 2", + di->decoder->name, sz); goto err; } /* The first element should be an integer. */ py_tmp = PyList_GetItem(obj, 0); if (!PyLong_Check(py_tmp)) { - srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY list, " - "but first element was not an integer.", di->decoder->name); + srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY list, but first element was not an integer.", + di->decoder->name); goto err; } bin_class = PyLong_AsLong(py_tmp); if (!(class_name = g_slist_nth_data(di->decoder->binary, bin_class))) { - srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY with " - "unregistered binary class %d.", di->decoder->name, bin_class); + srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY with unregistered binary class %d.", + di->decoder->name, bin_class); goto err; } /* Second element should be bytes. */ py_tmp = PyList_GetItem(obj, 1); if (!PyBytes_Check(py_tmp)) { - srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY list, " - "but second element was not bytes.", di->decoder->name); + srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY list, but second element was not bytes.", + di->decoder->name); goto err; } /* Consider an empty set of bytes a bug. */ if (PyBytes_Size(py_tmp) == 0) { - srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY " - "with empty data set.", di->decoder->name); + srd_err("Protocol decoder %s submitted SRD_OUTPUT_BINARY with empty data set.", + di->decoder->name); goto err; } @@ -194,15 +275,12 @@ static int convert_binary(struct srd_decoder_inst *di, PyObject *obj, PyGILState_Release(gstate); - pdb = g_malloc(sizeof(struct srd_proto_data_binary)); + pdb = pdata->data; pdb->bin_class = bin_class; pdb->size = size; - if (!(pdb->data = g_try_malloc(pdb->size))) { - g_free(pdb); + if (!(pdb->data = g_try_malloc(pdb->size))) return SRD_ERR_MALLOC; - } memcpy((void *)pdb->data, (const void *)buf, pdb->size); - pdata->data = pdb; return SRD_OK; @@ -260,7 +338,7 @@ static inline struct srd_decoder_inst *srd_inst_find_by_obj( sess = sessions->data; di = sess->di_list->data; if (di->py_inst == obj) - return di; + return di; di = NULL; for (l = sessions; di == NULL && l != NULL; l = l->next) { @@ -281,8 +359,8 @@ static int convert_meta(struct srd_proto_data *pdata, PyObject *obj) 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."); + PyErr_Format(PyExc_TypeError, + "This output was registered as 'int', but something else was passed."); goto err; } intvalue = PyLong_AsLongLong(obj); @@ -291,8 +369,8 @@ static int convert_meta(struct srd_proto_data *pdata, PyObject *obj) pdata->data = g_variant_new_int64(intvalue); } 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."); + PyErr_Format(PyExc_TypeError, + "This output was registered as 'float', but something else was passed."); goto err; } dvalue = PyFloat_AsDouble(obj); @@ -318,6 +396,13 @@ static void release_meta(GVariant *gvar) g_variant_unref(gvar); } +PyDoc_STRVAR(Decoder_put_doc, + "Put an annotation for the specified span of samples.\n" + "\n" + "Arguments: start and end sample number, stream id, annotation data.\n" + "Annotation data's layout depends on the output stream type." +); + static PyObject *Decoder_put(PyObject *self, PyObject *args) { GSList *l; @@ -325,6 +410,9 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) struct srd_decoder_inst *di, *next_di; struct srd_pd_output *pdo; struct srd_proto_data pdata; + struct srd_proto_data_annotation pda; + struct srd_proto_data_binary pdb; + struct srd_proto_data_logic pdl; uint64_t start_sample, end_sample; int output_id; struct srd_pd_callback *cb; @@ -357,9 +445,13 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) } pdo = l->data; - srd_spew("Instance %s put %" PRIu64 "-%" PRIu64 " %s on oid %d.", - di->inst_id, start_sample, end_sample, - output_type_name(pdo->output_type), output_id); + /* Upon SRD_OUTPUT_PYTHON for stacked PDs, we have a nicer log message later. */ + if (pdo->output_type != SRD_OUTPUT_PYTHON && di->next_di != NULL) { + srd_spew("Instance %s put %" PRIu64 "-%" PRIu64 " %s on " + "oid %d (%s).", di->inst_id, start_sample, end_sample, + output_type_name(pdo->output_type), output_id, + pdo->proto_id); + } pdata.start_sample = start_sample; pdata.end_sample = end_sample; @@ -370,6 +462,7 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) case SRD_OUTPUT_ANN: /* Annotations are only fed to callbacks. */ if ((cb = srd_pd_output_callback_find(di->sess, pdo->output_type))) { + pdata.data = &pda; /* Convert from PyDict to srd_proto_data_annotation. */ if (convert_annotation(di, py_data, &pdata) != SRD_OK) { /* An error was already logged. */ @@ -384,11 +477,14 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) case SRD_OUTPUT_PYTHON: for (l = di->next_di; l; l = l->next) { next_di = l->data; - srd_spew("Sending %" PRIu64 "-%" PRIu64 " to instance %s", - start_sample, end_sample, next_di->inst_id); - if (!(py_res = PyObject_CallMethod( - next_di->py_inst, "decode", "KKO", start_sample, - end_sample, py_data))) { + srd_spew("Instance %s put %" PRIu64 "-%" PRIu64 " %s " + "on oid %d (%s) to instance %s.", di->inst_id, + start_sample, + end_sample, output_type_name(pdo->output_type), + output_id, pdo->proto_id, next_di->inst_id); + py_res = PyObject_CallMethod(next_di->py_inst, "decode", + "KKO", start_sample, end_sample, py_data); + if (!py_res) { srd_exception_catch("Calling %s decode() failed", next_di->inst_id); } @@ -405,6 +501,7 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) break; case SRD_OUTPUT_BINARY: if ((cb = srd_pd_output_callback_find(di->sess, pdo->output_type))) { + pdata.data = &pdb; /* Convert from PyDict to srd_proto_data_binary. */ if (convert_binary(di, py_data, &pdata) != SRD_OK) { /* An error was already logged. */ @@ -416,6 +513,25 @@ static PyObject *Decoder_put(PyObject *self, PyObject *args) release_binary(pdata.data); } break; + case SRD_OUTPUT_LOGIC: + if ((cb = srd_pd_output_callback_find(di->sess, pdo->output_type))) { + pdata.data = &pdl; + /* Convert from PyDict to srd_proto_data_logic. */ + if (convert_logic(di, py_data, &pdata) != SRD_OK) { + /* An error was already logged. */ + break; + } + if (end_sample <= start_sample) { + srd_err("Ignored SRD_OUTPUT_LOGIC with invalid sample range."); + break; + } + pdl.repeat_count = (end_sample - start_sample) - 1; + Py_BEGIN_ALLOW_THREADS + cb->cb(&pdata, cb->cb_data); + Py_END_ALLOW_THREADS + release_logic(pdata.data); + } + break; case SRD_OUTPUT_META: if ((cb = srd_pd_output_callback_find(di->sess, pdo->output_type))) { /* Annotations need converting from PyObject. */ @@ -445,8 +561,12 @@ err: return NULL; } -static PyObject *Decoder_register(PyObject *self, PyObject *args, - PyObject *kwargs) +PyDoc_STRVAR(Decoder_register_doc, + "Register a new output stream." +); + +static PyObject *Decoder_register(PyObject *self, + PyObject *args, PyObject *kwargs) { struct srd_decoder_inst *di; struct srd_pd_output *pdo; @@ -516,9 +636,6 @@ static PyObject *Decoder_register(PyObject *self, PyObject *args, return py_new_output_id; } - srd_dbg("Instance %s creating new output type %d for %s.", - di->inst_id, output_type, proto_id); - pdo = g_malloc(sizeof(struct srd_pd_output)); /* pdo_id is just a simple index, nothing is deleted from this list anyway. */ @@ -538,6 +655,10 @@ static PyObject *Decoder_register(PyObject *self, PyObject *args, PyGILState_Release(gstate); + srd_dbg("Instance %s creating new output type %s as oid %d (%s).", + di->inst_id, output_type_name(output_type), pdo->pdo_id, + proto_id); + return py_new_output_id; err: @@ -599,13 +720,13 @@ static PyObject *get_current_pinvalues(const struct srd_decoder_inst *di) /* A channelmap value of -1 means "unused optional channel". */ if (di->dec_channelmap[i] == -1) { /* Value of unused channel is 0xff, instead of 0 or 1. */ - PyTuple_SetItem(py_pinvalues, i, PyLong_FromLong(0xff)); + PyTuple_SetItem(py_pinvalues, i, PyLong_FromUnsignedLong(0xff)); } else { sample_pos = di->inbuf + ((di->abs_cur_samplenum - di->abs_start_samplenum) * di->data_unitsize); byte_offset = di->dec_channelmap[i] / 8; bit_offset = di->dec_channelmap[i] % 8; sample = *(sample_pos + byte_offset) & (1 << bit_offset) ? 1 : 0; - PyTuple_SetItem(py_pinvalues, i, PyLong_FromLong(sample)); + PyTuple_SetItem(py_pinvalues, i, PyLong_FromUnsignedLong(sample)); } } @@ -619,18 +740,20 @@ static PyObject *get_current_pinvalues(const struct srd_decoder_inst *di) * * If there are no terms in the condition, 'term_list' will be NULL. * + * @param di The decoder instance to use. Must not be NULL. * @param py_dict A Python dict containing terms. Must not be NULL. * @param term_list Pointer to a GSList which will be set to the newly * created list of terms. Must not be NULL. * * @return SRD_OK upon success, a negative error code otherwise. */ -static int create_term_list(PyObject *py_dict, GSList **term_list) +static int create_term_list(struct srd_decoder_inst *di, + PyObject *py_dict, GSList **term_list) { Py_ssize_t pos = 0; PyObject *py_key, *py_value; struct srd_term *term; - uint64_t num_samples_to_skip; + int64_t num_samples_to_skip; char *term_str; PyGILState_STATE gstate; @@ -647,7 +770,6 @@ static int create_term_list(PyObject *py_dict, GSList **term_list) /* Check whether the current key is a string or a number. */ if (PyLong_Check(py_key)) { /* The key is a number. */ - /* TODO: Check if the number is a valid channel. */ /* Get the value string. */ if ((py_pydictitem_as_str(py_dict, py_key, &term_str)) != SRD_OK) { srd_err("Failed to get the value."); @@ -656,10 +778,12 @@ static int create_term_list(PyObject *py_dict, GSList **term_list) term = g_malloc(sizeof(struct srd_term)); term->type = get_term_type(term_str); term->channel = PyLong_AsLong(py_key); + if (term->channel < 0 || term->channel >= di->dec_num_channels) + term->type = SRD_TERM_ALWAYS_FALSE; g_free(term_str); } else if (PyUnicode_Check(py_key)) { /* The key is a string. */ - /* TODO: Check if it's "skip". */ + /* TODO: Check if the key is "skip". */ if ((py_pydictitem_as_long(py_dict, py_key, &num_samples_to_skip)) != SRD_OK) { srd_err("Failed to get number of samples to skip."); goto err; @@ -668,6 +792,8 @@ static int create_term_list(PyObject *py_dict, GSList **term_list) term->type = SRD_TERM_SKIP; term->num_samples_to_skip = num_samples_to_skip; term->num_samples_already_skipped = 0; + if (num_samples_to_skip < 0) + term->type = SRD_TERM_ALWAYS_FALSE; } else { srd_err("Term key is neither a string nor a number."); goto err; @@ -747,14 +873,14 @@ static int set_new_condition_list(PyObject *self, PyObject *args) num_conditions = PyList_Size(py_conditionlist); if (num_conditions == 0) goto ret_9999; /* The PD invoked self.wait([]). */ - Py_IncRef(py_conditionlist); + Py_INCREF(py_conditionlist); } else if (PyDict_Check(py_conds)) { /* 'py_conds' is a dict. */ if (PyDict_Size(py_conds) == 0) goto ret_9999; /* The PD invoked self.wait({}). */ /* Make a list and put the dict in there for convenience. */ py_conditionlist = PyList_New(1); - Py_IncRef(py_conds); + Py_INCREF(py_conds); PyList_SetItem(py_conditionlist, 0, py_conds); num_conditions = 1; } else { @@ -778,7 +904,7 @@ static int set_new_condition_list(PyObject *self, PyObject *args) } /* Create the list of terms in this condition. */ - if ((ret = create_term_list(py_dict, &term_list)) < 0) + if ((ret = create_term_list(di, py_dict, &term_list)) < 0) break; /* Add the new condition to the PD instance's condition list. */ @@ -837,6 +963,23 @@ static int set_skip_condition(struct srd_decoder_inst *di, uint64_t count) return SRD_OK; } +PyDoc_STRVAR(Decoder_wait_doc, + "Wait for one or more conditions to occur.\n" + "\n" + "Returns the sample data at the next position where the condition\n" + "is seen. When the optional condition is missing or empty, the next\n" + "sample number is used. The condition can be a dictionary with one\n" + "condition's details, or a list of dictionaries specifying multiple\n" + "conditions of which at least one condition must be true. Dicts can\n" + "contain one or more key/value pairs, all of which must be true for\n" + "the dict's condition to be considered true. The key either is a\n" + "channel index or a keyword, the value is the operation's parameter.\n" + "\n" + "Supported parameters for channel number keys: 'h', 'l', 'r', 'f',\n" + "or 'e' for level or edge conditions. Other supported keywords:\n" + "'skip' to advance over the given number of samples.\n" +); + static PyObject *Decoder_wait(PyObject *self, PyObject *args) { int ret; @@ -844,7 +987,7 @@ static PyObject *Decoder_wait(PyObject *self, PyObject *args) unsigned int i; gboolean found_match; struct srd_decoder_inst *di; - PyObject *py_pinvalues, *py_matched; + PyObject *py_pinvalues, *py_matched, *py_samplenum; PyGILState_STATE gstate; if (!self || !args) @@ -911,14 +1054,16 @@ static PyObject *Decoder_wait(PyObject *self, PyObject *args) /* If there's a match, set self.samplenum etc. and return. */ if (found_match) { /* Set self.samplenum to the (absolute) sample number that matched. */ - PyObject_SetAttrString(di->py_inst, "samplenum", - PyLong_FromLong(di->abs_cur_samplenum)); + py_samplenum = PyLong_FromUnsignedLongLong(di->abs_cur_samplenum); + PyObject_SetAttrString(di->py_inst, "samplenum", py_samplenum); + Py_DECREF(py_samplenum); if (di->match_array && di->match_array->len > 0) { py_matched = PyTuple_New(di->match_array->len); for (i = 0; i < di->match_array->len; i++) PyTuple_SetItem(py_matched, i, PyBool_FromLong(di->match_array->data[i])); PyObject_SetAttrString(di->py_inst, "matched", py_matched); + Py_DECREF(py_matched); match_array_free(di); } else { PyObject_SetAttrString(di->py_inst, "matched", Py_None); @@ -944,6 +1089,27 @@ static PyObject *Decoder_wait(PyObject *self, PyObject *args) /* Signal the main thread that we handled all samples. */ g_cond_signal(&di->handled_all_samples_cond); + /* + * When EOF was provided externally, communicate the + * Python EOFError exception to .decode() and return + * from the .wait() method call. This is motivated by + * the use of Python context managers, so that .decode() + * methods can "close" incompletely accumulated data + * when the sample data is exhausted. + */ + if (di->communicate_eof) { + /* Advance self.samplenum to the (absolute) last sample number. */ + py_samplenum = PyLong_FromUnsignedLongLong(di->abs_cur_samplenum); + PyObject_SetAttrString(di->py_inst, "samplenum", py_samplenum); + Py_DECREF(py_samplenum); + /* Raise an EOFError Python exception. */ + srd_dbg("%s: %s: Raising EOF from wait().", + di->inst_id, __func__); + g_mutex_unlock(&di->data_mutex); + PyErr_SetString(PyExc_EOFError, "samples exhausted"); + goto err; + } + /* * When termination of wait() and decode() was requested, * then exit the loop after releasing the mutex. @@ -968,6 +1134,14 @@ err: return NULL; } +PyDoc_STRVAR(Decoder_has_channel_doc, + "Check whether input data is supplied for a given channel.\n" + "\n" + "Argument: A channel index.\n" + "Returns: A boolean, True if the channel is connected,\n" + "False if the channel is open (won't see any input data).\n" +); + /** * Return whether the specified channel was supplied to the decoder. * @@ -983,6 +1157,7 @@ static PyObject *Decoder_has_channel(PyObject *self, PyObject *args) int idx, count; struct srd_decoder_inst *di; PyGILState_STATE gstate; + PyObject *bool_ret; if (!self || !args) return NULL; @@ -1013,7 +1188,9 @@ static PyObject *Decoder_has_channel(PyObject *self, PyObject *args) PyGILState_Release(gstate); - return (di->dec_channelmap[idx] == -1) ? Py_False : Py_True; + bool_ret = (di->dec_channelmap[idx] == -1) ? Py_False : Py_True; + Py_INCREF(bool_ret); + return bool_ret; err: PyGILState_Release(gstate); @@ -1021,16 +1198,26 @@ err: return NULL; } +PyDoc_STRVAR(Decoder_doc, "sigrok Decoder base class"); + 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" }, - {NULL, NULL, 0, NULL} + { "put", + Decoder_put, METH_VARARGS, + Decoder_put_doc, + }, + { "register", + (PyCFunction)(void(*)(void))Decoder_register, METH_VARARGS | METH_KEYWORDS, + Decoder_register_doc, + }, + { "wait", + Decoder_wait, METH_VARARGS, + Decoder_wait_doc, + }, + { "has_channel", + Decoder_has_channel, METH_VARARGS, + Decoder_has_channel_doc, + }, + ALL_ZERO, }; /** @@ -1044,10 +1231,10 @@ SRD_PRIV PyObject *srd_Decoder_type_new(void) { PyType_Spec spec; PyType_Slot slots[] = { - { Py_tp_doc, "sigrok Decoder base class" }, + { Py_tp_doc, Decoder_doc }, { Py_tp_methods, Decoder_methods }, { Py_tp_new, (void *)&PyType_GenericNew }, - { 0, NULL } + ALL_ZERO, }; PyObject *py_obj; PyGILState_STATE gstate;