X-Git-Url: https://sigrok.org/gitweb/?p=libsigrokdecode.git;a=blobdiff_plain;f=decoder.c;h=c379d4bdc5150dab53eef390f4d8e0030a680eb5;hp=d7780d5b8e5d0d6fe086a27ce363c7011e4d1a9e;hb=e195c025c303e361d0cc5a207f9c9443fb8deced;hpb=8ad6e500312084cd4ae43c7bda476cc7370cda20 diff --git a/decoder.c b/decoder.c index d7780d5..c379d4b 100644 --- a/decoder.c +++ b/decoder.c @@ -1,5 +1,5 @@ /* - * This file is part of the sigrok project. + * This file is part of the libsigrokdecode project. * * Copyright (C) 2010 Uwe Hermann * Copyright (C) 2012 Bert Vermeulen @@ -19,24 +19,46 @@ */ #include "config.h" -#include "sigrokdecode.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */ -#include "sigrokdecode-internal.h" +#include "libsigrokdecode.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */ +#include "libsigrokdecode-internal.h" #include +/** + * @file + * + * Listing, loading, unloading, and handling protocol decoders. + */ + +/** + * @defgroup grp_decoder Protocol decoders + * + * Handling protocol decoders. + * + * @{ + */ + +/** @cond PRIVATE */ + /* The list of protocol decoders. */ SRD_PRIV GSList *pd_list = NULL; +extern GSList *sessions; + /* module_sigrokdecode.c */ extern SRD_PRIV PyObject *mod_sigrokdecode; +/** @endcond */ + /** * Returns the list of supported/loaded protocol decoders. * * This is a GSList containing the names of the decoders as strings. * * @return List of decoders, NULL if none are supported or loaded. + * + * @since 0.1.0 (but the API changed in 0.2.0) */ -SRD_API GSList *srd_decoder_list(void) +SRD_API const GSList *srd_decoder_list(void) { return pd_list; } @@ -47,13 +69,15 @@ SRD_API GSList *srd_decoder_list(void) * @param id The ID string of the decoder to return. * * @return The decoder with the specified ID, or NULL if not found. + * + * @since 0.1.0 */ SRD_API struct srd_decoder *srd_decoder_get_by_id(const char *id) { GSList *l; struct srd_decoder *dec; - for (l = srd_decoder_list(); l; l = l->next) { + for (l = pd_list; l; l = l->next) { dec = l->data; if (!strcmp(dec->id, id)) return dec; @@ -62,7 +86,8 @@ SRD_API struct srd_decoder *srd_decoder_get_by_id(const char *id) return NULL; } -static int get_probes(struct srd_decoder *d, char *attr, GSList **pl) +static int get_probes(const struct srd_decoder *d, const char *attr, + GSList **pl) { PyObject *py_probelist, *py_entry; struct srd_probe *p; @@ -120,19 +145,119 @@ err_out: return ret; } +static int get_options(struct srd_decoder *d) +{ + PyObject *py_opts, *py_keys, *py_values, *py_val, *py_desc, *py_default; + Py_ssize_t i; + struct srd_decoder_option *o; + gint64 def_long; + int num_keys, overflow, ret; + char *key, *def_str; + + ret = SRD_ERR_PYTHON; + key = NULL; + + if (!PyObject_HasAttrString(d->py_dec, "options")) + /* That's fine. */ + return SRD_OK; + + /* If present, options must be a dictionary. */ + py_opts = PyObject_GetAttrString(d->py_dec, "options"); + if (!PyDict_Check(py_opts)) { + srd_err("Protocol decoder %s options attribute is not " + "a dictionary.", d->name); + goto err_out; + } + + py_keys = PyDict_Keys(py_opts); + py_values = PyDict_Values(py_opts); + num_keys = PyList_Size(py_keys); + for (i = 0; i < num_keys; i++) { + py_str_as_str(PyList_GetItem(py_keys, i), &key); + srd_dbg("option '%s'", key); + py_val = PyList_GetItem(py_values, i); + if (!PyList_Check(py_val) || PyList_Size(py_val) != 2) { + srd_err("Protocol decoder %s option '%s' value must be " + "a list with two elements.", d->name, key); + goto err_out; + } + py_desc = PyList_GetItem(py_val, 0); + if (!PyUnicode_Check(py_desc)) { + srd_err("Protocol decoder %s option '%s' has no " + "description.", d->name, key); + goto err_out; + } + py_default = PyList_GetItem(py_val, 1); + if (!PyUnicode_Check(py_default) && !PyLong_Check(py_default)) { + srd_err("Protocol decoder %s option '%s' has default " + "of unsupported type '%s'.", d->name, key, + Py_TYPE(py_default)->tp_name); + goto err_out; + } + if (!(o = g_try_malloc(sizeof(struct srd_decoder_option)))) { + srd_err("option malloc failed"); + goto err_out; + } + o->id = g_strdup(key); + py_str_as_str(py_desc, &o->desc); + if (PyUnicode_Check(py_default)) { + /* UTF-8 string */ + py_str_as_str(py_default, &def_str); + o->def = g_variant_new_string(def_str); + g_free(def_str); + } else { + /* Long */ + def_long = PyLong_AsLongAndOverflow(py_default, &overflow); + if (overflow) { + /* Value is < LONG_MIN or > LONG_MAX */ + PyErr_Clear(); + srd_err("Protocol decoder %s option '%s' has " + "invalid default value.", d->name, key); + goto err_out; + } + o->def = g_variant_new_int64(def_long); + } + g_variant_ref_sink(o->def); + d->options = g_slist_append(d->options, o); + g_free(key); + key = NULL; + } + Py_DecRef(py_keys); + Py_DecRef(py_values); + + ret = SRD_OK; + +err_out: + Py_XDECREF(py_opts); + g_free(key); + + return ret; +} + /** * Load a protocol decoder module into the embedded Python interpreter. * - * @param name The module name to be loaded. + * @param module_name The module name to be loaded. * * @return SRD_OK upon success, a (negative) error code otherwise. + * + * @since 0.1.0 */ SRD_API int srd_decoder_load(const char *module_name) { - PyObject *py_basedec, *py_method, *py_attr, *py_annlist, *py_ann; + PyObject *py_basedec, *py_method, *py_attr, *py_annlist, *py_ann, \ + *py_bin_classes, *py_bin_class; struct srd_decoder *d; - int alen, ret, i; - char **ann; + int len, ret, i; + char **ann, *bin; + struct srd_probe *p; + GSList *l; + + if (!srd_check_init()) + return SRD_ERR; + + if (!module_name) + return SRD_ERR_ARG; srd_dbg("Loading protocol decoder '%s'.", module_name); @@ -148,7 +273,7 @@ SRD_API int srd_decoder_load(const char *module_name) /* Import the Python module. */ if (!(d->py_mod = PyImport_ImportModule(module_name))) { - catch_exception("Import of '%s' failed.", module_name); + srd_exception_catch("Import of '%s' failed.", module_name); goto err_out; } @@ -201,17 +326,8 @@ SRD_API int srd_decoder_load(const char *module_name) } Py_CLEAR(py_method); - /* If present, options must be a dictionary. */ - if (PyObject_HasAttrString(d->py_dec, "options")) { - py_attr = PyObject_GetAttrString(d->py_dec, "options"); - if (!PyDict_Check(py_attr)) { - srd_err("Protocol decoder %s options attribute is not " - "a dictionary.", d->name); - Py_DecRef(py_attr); - goto err_out; - } - Py_DecRef(py_attr); - } + if (get_options(d) != SRD_OK) + goto err_out; /* Check and import required probes. */ if (get_probes(d, "probes", &d->probes) != SRD_OK) @@ -221,6 +337,19 @@ SRD_API int srd_decoder_load(const char *module_name) if (get_probes(d, "optional_probes", &d->opt_probes) != SRD_OK) goto err_out; + /* + * Fix order numbers for the optional probes. + * + * Example: + * Required probes: r1, r2, r3. Optional: o1, o2, o3, o4. + * 'order' fields in the d->probes list = 0, 1, 2. + * 'order' fields in the d->opt_probes list = 3, 4, 5, 6. + */ + for (l = d->opt_probes; l; l = l->next) { + p = l->data; + p->order += g_slist_length(d->probes); + } + /* Store required fields in newly allocated strings. */ if (py_attr_as_str(d->py_dec, "id", &(d->id)) != SRD_OK) goto err_out; @@ -237,11 +366,7 @@ SRD_API int srd_decoder_load(const char *module_name) if (py_attr_as_str(d->py_dec, "license", &(d->license)) != SRD_OK) goto err_out; - /* TODO: Handle inputformats, outputformats. */ - d->inputformats = NULL; - d->outputformats = NULL; - - /* Convert class annotation attribute to GSList of **char. */ + /* Convert annotation class attribute to GSList of char **. */ d->annotations = NULL; if (PyObject_HasAttrString(d->py_dec, "annotations")) { py_annlist = PyObject_GetAttrString(d->py_dec, "annotations"); @@ -250,8 +375,8 @@ SRD_API int srd_decoder_load(const char *module_name) "should be a list.", module_name); goto err_out; } - alen = PyList_Size(py_annlist); - for (i = 0; i < alen; i++) { + len = PyList_Size(py_annlist); + for (i = 0; i < len; i++) { py_ann = PyList_GetItem(py_annlist, i); if (!PyList_Check(py_ann) || PyList_Size(py_ann) != 2) { srd_err("Protocol decoder module %s " @@ -267,6 +392,31 @@ SRD_API int srd_decoder_load(const char *module_name) } } + /* Convert binary class to GSList of char *. */ + d->binary = NULL; + if (PyObject_HasAttrString(d->py_dec, "binary")) { + py_bin_classes = PyObject_GetAttrString(d->py_dec, "binary"); + if (!PyTuple_Check(py_bin_classes)) { + srd_err("Protocol decoder module %s binary classes " + "should be a tuple.", module_name); + goto err_out; + } + len = PyTuple_Size(py_bin_classes); + for (i = 0; i < len; i++) { + py_bin_class = PyTuple_GetItem(py_bin_classes, i); + if (!PyUnicode_Check(py_bin_class)) { + srd_err("Protocol decoder module %s binary " + "class should be a string.", module_name); + goto err_out; + } + + if (py_str_as_str(py_bin_class, &bin) != SRD_OK) { + goto err_out; + } + d->binary = g_slist_append(d->binary, bin); + } + } + /* Append it to the list of supported/loaded decoders. */ pd_list = g_slist_append(pd_list, d); @@ -291,17 +441,25 @@ err_out: * * @return A newly allocated buffer containing the protocol decoder's * documentation. The caller is responsible for free'ing the buffer. + * + * @since 0.1.0 */ -SRD_API char *srd_decoder_doc(const struct srd_decoder *dec) +SRD_API char *srd_decoder_doc_get(const struct srd_decoder *dec) { PyObject *py_str; char *doc; + if (!srd_check_init()) + return NULL; + + if (!dec) + return NULL; + if (!PyObject_HasAttrString(dec->py_mod, "__doc__")) return NULL; if (!(py_str = PyObject_GetAttrString(dec->py_mod, "__doc__"))) { - catch_exception(""); + srd_exception_catch(""); return NULL; } @@ -332,14 +490,26 @@ static void free_probes(GSList *probelist) } /** - * Unload decoder module. + * Unload the specified protocol decoder. * * @param dec The struct srd_decoder to be unloaded. * * @return SRD_OK upon success, a (negative) error code otherwise. + * + * @since 0.1.0 */ SRD_API int srd_decoder_unload(struct srd_decoder *dec) { + struct srd_decoder_option *o; + struct srd_session *sess; + GSList *l; + + if (!srd_check_init()) + return SRD_ERR; + + if (!dec) + return SRD_ERR_ARG; + srd_dbg("Unloading protocol decoder '%s'.", dec->name); /* @@ -348,7 +518,19 @@ SRD_API int srd_decoder_unload(struct srd_decoder *dec) * stack. A frontend reloading a decoder thus has to restart all * instances, and rebuild the stack. */ - srd_inst_free_all(NULL); + for (l = sessions; l; l = l->next) { + sess = l->data; + srd_inst_free_all(sess, NULL); + } + + for (l = dec->options; l; l = l->next) { + o = l->data; + g_free(o->id); + g_free(o->desc); + g_variant_unref(o->def); + g_free(o); + } + g_slist_free(dec->options); free_probes(dec->probes); free_probes(dec->opt_probes); @@ -358,18 +540,12 @@ SRD_API int srd_decoder_unload(struct srd_decoder *dec) g_free(dec->desc); g_free(dec->license); - /* TODO: Free everything in inputformats and outputformats. */ - if (dec->inputformats != NULL) - g_slist_free(dec->inputformats); - if (dec->outputformats != NULL) - g_slist_free(dec->outputformats); - /* The module's Decoder class. */ Py_XDECREF(dec->py_dec); /* The module itself. */ Py_XDECREF(dec->py_mod); - /* TODO: (g_)free dec itself? */ + g_free(dec); return SRD_OK; } @@ -378,6 +554,8 @@ SRD_API int srd_decoder_unload(struct srd_decoder *dec) * Load all installed protocol decoders. * * @return SRD_OK upon success, a (negative) error code otherwise. + * + * @since 0.1.0 */ SRD_API int srd_decoder_load_all(void) { @@ -385,6 +563,9 @@ SRD_API int srd_decoder_load_all(void) GError *error; const gchar *direntry; + if (!srd_check_init()) + return SRD_ERR; + if (!(dir = g_dir_open(DECODERS_DIR, 0, &error))) { srd_err("Unable to open %s for reading.", DECODERS_DIR); return SRD_ERR_DECODERS_DIR; @@ -403,16 +584,20 @@ SRD_API int srd_decoder_load_all(void) * Unload all loaded protocol decoders. * * @return SRD_OK upon success, a (negative) error code otherwise. + * + * @since 0.1.0 */ SRD_API int srd_decoder_unload_all(void) { GSList *l; struct srd_decoder *dec; - for (l = srd_decoder_list(); l; l = l->next) { + for (l = pd_list; l; l = l->next) { dec = l->data; srd_decoder_unload(dec); } return SRD_OK; } + +/** @} */