]> sigrok.org Git - libsigrokdecode.git/blobdiff - controller.c
srd: extra module path can now optionally be passed to srd_init()
[libsigrokdecode.git] / controller.c
index d7d3faf2999e074567e6ce9a60ab26d82fae7e70..8b9f793750bc7c9658c5e7e3fd51fcdd0ea3d105 100644 (file)
 #include <inttypes.h>
 #include <stdlib.h>
 
-
 /* List of decoder instances. */
 static GSList *di_list = NULL;
 
 /* List of frontend callbacks to receive PD output. */
 static GSList *callbacks = NULL;
 
-/* lives in decoder.c */
-extern GSList *pd_list;
-
-/* lives in module_sigrokdecode.c */
-extern PyMODINIT_FUNC PyInit_sigrokdecode(void);
+/* decoder.c */
+extern SRD_PRIV GSList *pd_list;
 
-/* lives in type_logic.c */
-extern PyTypeObject srd_logic_type;
+/* module_sigrokdecode.c */
+extern SRD_PRIV PyMODINIT_FUNC PyInit_sigrokdecode(void);
 
+/* type_logic.c */
+extern SRD_PRIV PyTypeObject srd_logic_type;
 
 /**
  * Initialize libsigrokdecode.
@@ -59,28 +57,49 @@ extern PyTypeObject srd_logic_type;
  * Multiple calls to srd_init(), without calling srd_exit() in between,
  * are not allowed.
  *
+ * @param path Path to an extra directory containing protocol decoders
+ *             which will be added to the python sys.path, or NULL.
+ *
  * @return SRD_OK upon success, a (negative) error code otherwise.
  *         Upon Python errors, return SRD_ERR_PYTHON. If the sigrok decoders
  *         directory cannot be accessed, return SRD_ERR_DECODERS_DIR.
  *         If not enough memory could be allocated, return SRD_ERR_MALLOC.
  */
-int srd_init(void)
+SRD_API int srd_init(char *path)
 {
        int ret;
+       char *env_path;
 
        srd_dbg("Initializing libsigrokdecode.");
 
        /* Add our own module to the list of built-in modules. */
        PyImport_AppendInittab("sigrokdecode", PyInit_sigrokdecode);
 
-       /* Initialize the python interpreter. */
+       /* Initialize the Python interpreter. */
        Py_Initialize();
 
-       if ((ret = set_modulepath()) != SRD_OK) {
+       /* Installed decoders. */
+       if ((ret = add_modulepath(DECODERS_DIR)) != SRD_OK) {
                Py_Finalize();
                return ret;
        }
 
+       /* Path specified by the user. */
+       if (path) {
+               if ((ret = add_modulepath(path)) != SRD_OK) {
+                       Py_Finalize();
+                       return ret;
+               }
+       }
+
+       /* Environment variable overrides everything, for debugging. */
+       if ((env_path = getenv("SIGROKDECODE_DIR"))) {
+               if ((ret = add_modulepath(path)) != SRD_OK) {
+                       Py_Finalize();
+                       return ret;
+               }
+       }
+
        if ((ret = srd_load_all_decoders()) != SRD_OK) {
                Py_Finalize();
                return ret;
@@ -89,7 +108,6 @@ int srd_init(void)
        return SRD_OK;
 }
 
-
 /**
  * Shutdown libsigrokdecode.
  *
@@ -102,9 +120,8 @@ int srd_init(void)
  *
  * @return SRD_OK upon success, a (negative) error code otherwise.
  */
-int srd_exit(void)
+SRD_API int srd_exit(void)
 {
-
        srd_dbg("Exiting libsigrokdecode.");
 
        srd_unload_all_decoders();
@@ -116,7 +133,6 @@ int srd_exit(void)
        return SRD_OK;
 }
 
-
 /**
  * Add an additional search directory for the protocol decoders.
  *
@@ -127,43 +143,64 @@ int srd_exit(void)
  * Python modules which have the same name as a sigrok protocol decoder in
  * sys.path or in the current working directory.
  *
- * TODO: add path from env var SIGROKDECODE_PATH, config etc
- * TODO: Should take directoryname/path as input.
+ * @param path Path to an extra directory containing protocol decoders
+ *             which will be added to the python sys.path, or NULL.
  *
- * @return TODO.
+ * @return SRD_OK upon success, a (negative) error code otherwise.
  */
-int set_modulepath(void)
+SRD_PRIV int add_modulepath(const char *path)
 {
-       int ret;
-       gchar *path, *s;
-
-#ifdef _WIN32
-       gchar **splitted;
-
-       /*
-        * On Windows/MinGW, Python's sys.path needs entries of the form
-        * 'C:\\foo\\bar' instead of '/foo/bar'.
-        */
-
-       splitted = g_strsplit(DECODERS_DIR, "/", 0);
-       path = g_build_pathv("\\\\", splitted);
-       g_strfreev(splitted);
-#else
-       path = g_strdup(DECODERS_DIR);
-#endif
-
-       /* TODO: Sanity check on 'path' (length, escape special chars, ...). */
-       s = g_strdup_printf("import sys; sys.path.insert(0, r'%s')", path);
-
-       ret = PyRun_SimpleString(s);
+       PyObject *py_cur_path, *py_item;
+       GString *new_path;
+       int wc_len, i;
+       wchar_t *wc_new_path;
+       char *item;
+
+       srd_dbg("adding %s to module path", path);
+
+       new_path = g_string_sized_new(256);
+       g_string_assign(new_path, g_strdup(path));
+       py_cur_path = PySys_GetObject("path");
+       for (i = 0; i < PyList_Size(py_cur_path); i++) {
+               g_string_append(new_path, g_strdup(G_SEARCHPATH_SEPARATOR_S));
+               py_item = PyList_GetItem(py_cur_path, i);
+               if (!PyUnicode_Check(py_item))
+                       /* Shouldn't happen. */
+                       continue;
+               if (py_str_as_str(py_item, &item) != SRD_OK)
+                       continue;
+               g_string_append(new_path, item);
+       }
 
-       g_free(path);
-       g_free(s);
+       /* Convert to wide chars. */
+       wc_len = sizeof(wchar_t) * (new_path->len + 1);
+       if (!(wc_new_path = g_try_malloc(wc_len))) {
+               srd_dbg("malloc failed");
+               return SRD_ERR_MALLOC;
+       }
+       mbstowcs(wc_new_path, new_path->str, wc_len);
+       PySys_SetPath(wc_new_path);
+       g_string_free(new_path, TRUE);
+       g_free(wc_new_path);
+
+//#ifdef _WIN32
+//     gchar **splitted;
+//
+//     /*
+//      * On Windows/MinGW, Python's sys.path needs entries of the form
+//      * 'C:\\foo\\bar' instead of '/foo/bar'.
+//      */
+//
+//     splitted = g_strsplit(DECODERS_DIR, "/", 0);
+//     path = g_build_pathv("\\\\", splitted);
+//     g_strfreev(splitted);
+//#else
+//     path = g_strdup(DECODERS_DIR);
+//#endif
 
-       return ret;
+       return SRD_OK;
 }
 
-
 /**
  * Set options in a decoder instance.
  *
@@ -174,8 +211,8 @@ int set_modulepath(void)
  *
  * @return SRD_OK upon success, a (negative) error code otherwise.
  */
-int srd_instance_set_options(struct srd_decoder_instance *di,
-               GHashTable *options)
+SRD_API int srd_inst_set_options(struct srd_decoder_inst *di,
+                                    GHashTable *options)
 {
        PyObject *py_dec_options, *py_dec_optkeys, *py_di_options, *py_optval;
        PyObject *py_optlist, *py_classval;
@@ -184,7 +221,7 @@ int srd_instance_set_options(struct srd_decoder_instance *di,
        int num_optkeys, ret, size, i;
        char *key, *value;
 
-       if(!PyObject_HasAttrString(di->decoder->py_dec, "options")) {
+       if (!PyObject_HasAttrString(di->decoder->py_dec, "options")) {
                /* Decoder has no options. */
                if (g_hash_table_size(options) == 0) {
                        /* No options provided. */
@@ -205,7 +242,7 @@ int srd_instance_set_options(struct srd_decoder_instance *di,
        /* All of these are synthesized objects, so they're good. */
        py_dec_optkeys = PyDict_Keys(py_dec_options);
        num_optkeys = PyList_Size(py_dec_optkeys);
-       if (!(py_di_options = PyObject_GetAttrString(di->py_instance, "options")))
+       if (!(py_di_options = PyObject_GetAttrString(di->py_inst, "options")))
                goto err_out;
        for (i = 0; i < num_optkeys; i++) {
                /* Get the default class value for this option. */
@@ -215,7 +252,8 @@ int srd_instance_set_options(struct srd_decoder_instance *di,
                if (!(py_classval = PyList_GetItem(py_optlist, 1)))
                        goto err_out;
                if (!PyUnicode_Check(py_classval) && !PyLong_Check(py_classval)) {
-                       srd_err("Options of type %s are not yet supported.", Py_TYPE(py_classval)->tp_name);
+                       srd_err("Options of type %s are not yet supported.",
+                               Py_TYPE(py_classval)->tp_name);
                        goto err_out;
                }
 
@@ -231,8 +269,9 @@ int srd_instance_set_options(struct srd_decoder_instance *di,
                                if (!(py_optval = PyLong_FromString(value, NULL, 0))) {
                                        /* ValueError Exception */
                                        PyErr_Clear();
-                                       srd_err("Option %s has invalid value %s: expected integer.",
-                                                       key, value);
+                                       srd_err("Option %s has invalid value "
+                                               "%s: expected integer.",
+                                               key, value);
                                        goto err_out;
                                }
                        }
@@ -250,7 +289,8 @@ int srd_instance_set_options(struct srd_decoder_instance *di,
                                if (val_ull == (unsigned long long)-1) {
                                        /* OverFlowError exception */
                                        PyErr_Clear();
-                                       srd_err("Invalid integer value for %s: expected integer.", key);
+                                       srd_err("Invalid integer value for %s: "
+                                               "expected integer.", key);
                                        goto err_out;
                                }
                                if (!(py_optval = PyLong_FromUnsignedLongLong(val_ull)))
@@ -274,15 +314,14 @@ err_out:
        Py_XDECREF(py_dec_options);
        g_free(key);
        if (PyErr_Occurred())
-               catch_exception("Stray exception in srd_instance_set_options().");
+               catch_exception("Stray exception in srd_inst_set_options().");
 
        return ret;
 }
 
-/* Helper GComparefunc for g_slist_find_custom() in srd_instance_set_probes() */
+/* Helper GComparefunc for g_slist_find_custom() in srd_inst_set_probes() */
 static gint compare_probe_id(struct srd_probe *a, char *probe_id)
 {
-
        return strcmp(a->id, probe_id);
 }
 
@@ -291,13 +330,12 @@ static gint compare_probe_id(struct srd_probe *a, char *probe_id)
  *
  * @param di Decoder instance.
  * @param probes A GHashTable of probes to set. Key is probe name, value is
- * the probe number. Samples passed to this instance will be arranged in this
- * order.
- *
+ *               the probe number. Samples passed to this instance will be
+ *               arranged in this order.
  * @return SRD_OK upon success, a (negative) error code otherwise.
  */
-int srd_instance_set_probes(struct srd_decoder_instance *di,
-               GHashTable *new_probes)
+SRD_API int srd_inst_set_probes(struct srd_decoder_inst *di,
+                                   GHashTable *new_probes)
 {
        GList *l;
        GSList *sl;
@@ -306,23 +344,23 @@ int srd_instance_set_probes(struct srd_decoder_instance *di,
        char *probe_id, *probenum_str;
 
        srd_dbg("set probes called for instance %s with list of %d probes",
-                       di->instance_id, g_hash_table_size(new_probes));
+               di->inst_id, g_hash_table_size(new_probes));
 
        if (g_hash_table_size(new_probes) == 0)
                /* No probes provided. */
                return SRD_OK;
 
-       if(di->dec_num_probes == 0) {
+       if (di->dec_num_probes == 0) {
                /* Decoder has no probes. */
                srd_err("Protocol decoder %s has no probes to define.",
-                               di->decoder->name);
+                       di->decoder->name);
                return SRD_ERR_ARG;
        }
 
        new_probemap = NULL;
 
        if (!(new_probemap = g_try_malloc(sizeof(int) * di->dec_num_probes))) {
-               srd_err("Failed to malloc new probe map.");
+               srd_err("Failed to g_malloc() new probe map.");
                return SRD_ERR_MALLOC;
        }
 
@@ -331,7 +369,8 @@ int srd_instance_set_probes(struct srd_decoder_instance *di,
                probenum_str = g_hash_table_lookup(new_probes, probe_id);
                if (!probenum_str) {
                        /* Probe name was specified without a value. */
-                       srd_err("No probe number was specified for %s.", probe_id);
+                       srd_err("No probe number was specified for %s.",
+                               probe_id);
                        g_free(new_probemap);
                        return SRD_ERR_ARG;
                }
@@ -340,16 +379,17 @@ int srd_instance_set_probes(struct srd_decoder_instance *di,
                                (GCompareFunc)compare_probe_id))) {
                        /* Fall back on optional probes. */
                        if (!(sl = g_slist_find_custom(di->decoder->opt_probes,
-                                       probe_id, (GCompareFunc)compare_probe_id))) {
-                               srd_err("Protocol decoder %s has no probe '%s'.",
-                                               di->decoder->name, probe_id);
+                            probe_id, (GCompareFunc) compare_probe_id))) {
+                               srd_err("Protocol decoder %s has no probe "
+                                       "'%s'.", di->decoder->name, probe_id);
                                g_free(new_probemap);
                                return SRD_ERR_ARG;
                        }
                }
                p = sl->data;
                new_probemap[p->order] = new_probenum;
-               srd_dbg("setting probe mapping for %d = probe %d", p->order, new_probenum);
+               srd_dbg("setting probe mapping for %d = probe %d", p->order,
+                       new_probenum);
        }
        g_free(di->dec_probemap);
        di->dec_probemap = new_probemap;
@@ -362,17 +402,17 @@ int srd_instance_set_probes(struct srd_decoder_instance *di,
  *
  * @param id Decoder 'id' field.
  * @param options GHashtable of options which override the defaults set in
- *         the decoder class.
- * @return Pointer to a newly allocated struct srd_decoder_instance, or
- *             NULL in case of failure.
+ *                the decoder class.
+ * @return Pointer to a newly allocated struct srd_decoder_inst, or
+ *         NULL in case of failure.
  */
-struct srd_decoder_instance *srd_instance_new(const char *decoder_id,
-               GHashTable *options)
+SRD_API struct srd_decoder_inst *srd_inst_new(const char *decoder_id,
+                                                     GHashTable *options)
 {
-       struct srd_decoder *dec;
-       struct srd_decoder_instance *di;
        int i;
-       char *instance_id;
+       struct srd_decoder *dec;
+       struct srd_decoder_inst *di;
+       char *inst_id;
 
        srd_dbg("Creating new %s instance.", decoder_id);
 
@@ -381,24 +421,25 @@ struct srd_decoder_instance *srd_instance_new(const char *decoder_id,
                return NULL;
        }
 
-       if (!(di = g_try_malloc0(sizeof(*di)))) {
-               srd_err("Failed to malloc instance.");
+       if (!(di = g_try_malloc0(sizeof(struct srd_decoder_inst)))) {
+               srd_err("Failed to g_malloc() instance.");
                return NULL;
        }
 
-       instance_id = g_hash_table_lookup(options, "id");
+       inst_id = g_hash_table_lookup(options, "id");
        di->decoder = dec;
-       di->instance_id = g_strdup(instance_id ? instance_id : decoder_id);
+       di->inst_id = g_strdup(inst_id ? inst_id : decoder_id);
        g_hash_table_remove(options, "id");
 
        /* Prepare a default probe map, where samples come in the
         * order in which the decoder class defined them.
         */
        di->dec_num_probes = g_slist_length(di->decoder->probes) +
-                       g_slist_length(di->decoder->opt_probes);
+                            g_slist_length(di->decoder->opt_probes);
        if (di->dec_num_probes) {
-               if (!(di->dec_probemap = g_try_malloc(sizeof(int) * di->dec_num_probes))) {
-                       srd_err("Failed to malloc probe map.");
+               if (!(di->dec_probemap =
+                    g_try_malloc(sizeof(int) * di->dec_num_probes))) {
+                       srd_err("Failed to g_malloc() probe map.");
                        g_free(di);
                        return NULL;
                }
@@ -407,15 +448,16 @@ struct srd_decoder_instance *srd_instance_new(const char *decoder_id,
        }
 
        /* Create a new instance of this decoder class. */
-       if (!(di->py_instance = PyObject_CallObject(dec->py_dec, NULL))) {
+       if (!(di->py_inst = PyObject_CallObject(dec->py_dec, NULL))) {
                if (PyErr_Occurred())
-                       catch_exception("failed to create %s instance: ", decoder_id);
+                       catch_exception("failed to create %s instance: ",
+                                       decoder_id);
                g_free(di->dec_probemap);
                g_free(di);
                return NULL;
        }
 
-       if (srd_instance_set_options(di, options) != SRD_OK) {
+       if (srd_inst_set_options(di, options) != SRD_OK) {
                g_free(di->dec_probemap);
                g_free(di);
                return NULL;
@@ -427,10 +469,9 @@ struct srd_decoder_instance *srd_instance_new(const char *decoder_id,
        return di;
 }
 
-int srd_instance_stack(struct srd_decoder_instance *di_from,
-               struct srd_decoder_instance *di_to)
+SRD_API int srd_inst_stack(struct srd_decoder_inst *di_from,
+                              struct srd_decoder_inst *di_to)
 {
-
        if (!di_from || !di_to) {
                srd_err("Invalid from/to instance pair.");
                return SRD_ERR_ARG;
@@ -452,19 +493,19 @@ int srd_instance_stack(struct srd_decoder_instance *di_from,
  * level of instances -- instances already stacked on top of another one
  * will not be found.
  *
- * @param instance_id The instance id to be found.
+ * @param inst_id The instance id to be found.
  *
- * @return Pointer to struct srd_decoder_instance, or NULL if not found.
+ * @return Pointer to struct srd_decoder_inst, or NULL if not found.
  */
-struct srd_decoder_instance *srd_instance_find_by_id(char *instance_id)
+SRD_API struct srd_decoder_inst *srd_inst_find_by_id(char *inst_id)
 {
        GSList *l;
-       struct srd_decoder_instance *tmp, *di;
+       struct srd_decoder_inst *tmp, *di;
 
        di = NULL;
        for (l = di_list; l; l = l->next) {
                tmp = l->data;
-               if (!strcmp(tmp->instance_id, instance_id)) {
+               if (!strcmp(tmp->inst_id, inst_id)) {
                        di = tmp;
                        break;
                }
@@ -474,53 +515,55 @@ struct srd_decoder_instance *srd_instance_find_by_id(char *instance_id)
 }
 
 /**
- * Finds a decoder instance by its python object, i.e. that instance's
+ * Finds a decoder instance by its Python object, i.e. that instance's
  * instantiation of the sigrokdecode.Decoder class. This will recurse
  * to find the instance anywhere in the stack tree.
  *
- * @param stack Pointer to a GSList of struct srd_decoder_instance,
+ * @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.
+ * @param obj The Python class instantiation.
  *
- * @return Pointer to struct srd_decoder_instance, or NULL if not found.
+ * @return Pointer to struct srd_decoder_inst, or NULL if not found.
  */
-struct srd_decoder_instance *srd_instance_find_by_obj(GSList *stack,
-               PyObject *obj)
+SRD_API struct srd_decoder_inst *srd_inst_find_by_obj(GSList *stack,
+                                                             PyObject *obj)
 {
        GSList *l;
-       struct srd_decoder_instance *tmp, *di;
+       struct srd_decoder_inst *tmp, *di;
 
        di = NULL;
        for (l = stack ? stack : di_list; di == NULL && l != NULL; l = l->next) {
                tmp = l->data;
-               if (tmp->py_instance == obj)
+               if (tmp->py_inst == obj)
                        di = tmp;
                else if (tmp->next_di)
-                       di = srd_instance_find_by_obj(tmp->next_di, obj);
+                       di = srd_inst_find_by_obj(tmp->next_di, obj);
        }
 
        return di;
 }
 
-int srd_instance_start(struct srd_decoder_instance *di, PyObject *args)
+SRD_API int srd_inst_start(struct srd_decoder_inst *di, PyObject *args)
 {
        PyObject *py_name, *py_res;
        GSList *l;
-       struct srd_decoder_instance *next_di;
+       struct srd_decoder_inst *next_di;
 
        srd_dbg("Calling start() method on protocol decoder instance %s.",
-               di->instance_id);
+               di->inst_id);
 
        if (!(py_name = PyUnicode_FromString("start"))) {
-               srd_err("Unable to build python object for 'start'.");
-               catch_exception("Protocol decoder instance %s: ", di->instance_id);
+               srd_err("Unable to build Python object for 'start'.");
+               catch_exception("Protocol decoder instance %s: ",
+                               di->inst_id);
                return SRD_ERR_PYTHON;
        }
 
-       if (!(py_res = PyObject_CallMethodObjArgs(di->py_instance,
-                       py_name, args, NULL))) {
-               catch_exception("Protocol decoder instance %s: ", di->instance_id);
+       if (!(py_res = PyObject_CallMethodObjArgs(di->py_inst,
+                                                 py_name, args, NULL))) {
+               catch_exception("Protocol decoder instance %s: ",
+                               di->inst_id);
                return SRD_ERR_PYTHON;
        }
 
@@ -533,7 +576,7 @@ int srd_instance_start(struct srd_decoder_instance *di, PyObject *args)
         */
        for (l = di->next_di; l; l = l->next) {
                next_di = l->data;
-               srd_instance_start(next_di, args);
+               srd_inst_start(next_di, args);
        }
 
        return SRD_OK;
@@ -550,15 +593,16 @@ int srd_instance_start(struct srd_decoder_instance *di, PyObject *args)
  *
  * @return SRD_OK upon success, a (negative) error code otherwise.
  */
-int srd_instance_decode(uint64_t start_samplenum,
-       struct srd_decoder_instance *di, uint8_t *inbuf, uint64_t inbuflen)
+SRD_API int srd_inst_decode(uint64_t start_samplenum,
+                               struct srd_decoder_inst *di,
+                               uint8_t *inbuf, uint64_t inbuflen)
 {
        PyObject *py_res;
        srd_logic *logic;
        uint64_t end_samplenum;
 
        srd_dbg("Calling decode() on instance %s with %d bytes starting "
-               "at sample %d.", di->instance_id, inbuflen, start_samplenum);
+               "at sample %d.", di->inst_id, inbuflen, start_samplenum);
 
        /* Return an error upon unusable input. */
        if (!di) {
@@ -587,11 +631,13 @@ int srd_instance_decode(uint64_t start_samplenum,
        logic->sample = PyList_New(2);
        Py_INCREF(logic->sample);
 
-       Py_IncRef(di->py_instance);
+       Py_IncRef(di->py_inst);
        end_samplenum = start_samplenum + inbuflen / di->data_unitsize;
-       if (!(py_res = PyObject_CallMethod(di->py_instance, "decode",
-                       "KKO", logic->start_samplenum, end_samplenum, logic))) {
-               catch_exception("Protocol decoder instance %s: ", di->instance_id);
+       if (!(py_res = PyObject_CallMethod(di->py_inst, "decode",
+                                          "KKO", logic->start_samplenum,
+                                          end_samplenum, logic))) {
+               catch_exception("Protocol decoder instance %s: ",
+                               di->inst_id);
                return SRD_ERR_PYTHON; /* TODO: More specific error? */
        }
        Py_DecRef(py_res);
@@ -599,15 +645,15 @@ int srd_instance_decode(uint64_t start_samplenum,
        return SRD_OK;
 }
 
-void srd_instance_free(struct srd_decoder_instance *di)
+SRD_API void srd_inst_free(struct srd_decoder_inst *di)
 {
        GSList *l;
        struct srd_pd_output *pdo;
 
-       srd_dbg("Freeing instance %s", di->instance_id);
+       srd_dbg("Freeing instance %s", di->inst_id);
 
-       Py_DecRef(di->py_instance);
-       g_free(di->instance_id);
+       Py_DecRef(di->py_inst);
+       g_free(di->inst_id);
        g_free(di->dec_probemap);
        g_slist_free(di->next_di);
        for (l = di->pd_output; l; l = l->next) {
@@ -616,33 +662,31 @@ void srd_instance_free(struct srd_decoder_instance *di)
                g_free(pdo);
        }
        g_slist_free(di->pd_output);
-
 }
 
-void srd_instance_free_all(GSList *stack)
+SRD_API void srd_inst_free_all(GSList *stack)
 {
        GSList *l;
-       struct srd_decoder_instance *di;
+       struct srd_decoder_inst *di;
 
        di = NULL;
        for (l = stack ? stack : di_list; di == NULL && l != NULL; l = l->next) {
                di = l->data;
                if (di->next_di)
-                       srd_instance_free_all(di->next_di);
-               srd_instance_free(di);
+                       srd_inst_free_all(di->next_di);
+               srd_inst_free(di);
        }
        if (!stack) {
                g_slist_free(di_list);
                di_list = NULL;
        }
-
 }
 
-int srd_session_start(int num_probes, int unitsize, uint64_t samplerate)
+SRD_API int srd_session_start(int num_probes, int unitsize, uint64_t samplerate)
 {
        PyObject *args;
        GSList *d;
-       struct srd_decoder_instance *di;
+       struct srd_decoder_inst *di;
        int ret;
 
        srd_dbg("Calling start() on all instances with %d probes, "
@@ -652,7 +696,7 @@ int srd_session_start(int num_probes, int unitsize, uint64_t samplerate)
         * samplerate. This can be extended as needed.
         */
        if (!(args = Py_BuildValue("{s:l}", "samplerate", (long)samplerate))) {
-               srd_err("Unable to build python object for metadata.");
+               srd_err("Unable to build Python object for metadata.");
                return SRD_ERR_PYTHON;
        }
 
@@ -662,7 +706,7 @@ int srd_session_start(int num_probes, int unitsize, uint64_t samplerate)
                di->data_num_probes = num_probes;
                di->data_unitsize = unitsize;
                di->data_samplerate = samplerate;
-               if ((ret = srd_instance_start(di, args) != SRD_OK))
+               if ((ret = srd_inst_start(di, args) != SRD_OK))
                        break;
        }
 
@@ -672,42 +716,46 @@ int srd_session_start(int num_probes, int unitsize, uint64_t samplerate)
 }
 
 /* Feed logic samples to decoder session. */
-int srd_session_feed(uint64_t start_samplenum, uint8_t *inbuf, uint64_t inbuflen)
+SRD_API int srd_session_feed(uint64_t start_samplenum, uint8_t * inbuf,
+                            uint64_t inbuflen)
 {
        GSList *d;
        int ret;
 
        srd_dbg("Calling decode() on all instances with starting sample "
-               "number %"PRIu64", %"PRIu64" bytes at 0x%p", start_samplenum,
-               inbuflen, inbuf);
+               "number %" PRIu64 ", %" PRIu64 " bytes at 0x%p",
+               start_samplenum, inbuflen, inbuf);
 
        for (d = di_list; d; d = d->next) {
-               if ((ret = srd_instance_decode(start_samplenum, d->data, inbuf,
-                               inbuflen)) != SRD_OK)
+               if ((ret = srd_inst_decode(start_samplenum, d->data, inbuf,
+                                              inbuflen)) != SRD_OK)
                        return ret;
        }
 
        return SRD_OK;
 }
 
-
-int srd_register_callback(int output_type, void *cb)
+SRD_API int srd_register_callback(int output_type,
+                                 srd_pd_output_callback_t cb, void *user_data)
 {
        struct srd_pd_callback *pd_cb;
 
        srd_dbg("Registering new callback for output type %d.", output_type);
 
-       if (!(pd_cb = g_try_malloc(sizeof(struct srd_pd_callback))))
+       if (!(pd_cb = g_try_malloc(sizeof(struct srd_pd_callback)))) {
+               srd_err("Failed to g_malloc() struct srd_pd_callback.");
                return SRD_ERR_MALLOC;
+       }
 
        pd_cb->output_type = output_type;
        pd_cb->callback = cb;
+       pd_cb->user_data = user_data;
        callbacks = g_slist_append(callbacks, pd_cb);
 
        return SRD_OK;
 }
 
-void *srd_find_callback(int output_type)
+SRD_API void *srd_find_callback(int output_type)
 {
        GSList *l;
        struct srd_pd_callback *pd_cb;
@@ -725,17 +773,19 @@ void *srd_find_callback(int output_type)
        return cb;
 }
 
-
-/* This is the backend function to python sigrokdecode.add() call. */
-int pd_add(struct srd_decoder_instance *di, int output_type, char *proto_id)
+/* This is the backend function to Python sigrokdecode.add() call. */
+SRD_PRIV int pd_add(struct srd_decoder_inst *di, int output_type,
+                   char *proto_id)
 {
        struct srd_pd_output *pdo;
 
        srd_dbg("Instance %s creating new output type %d for %s.",
-               di->instance_id, output_type, proto_id);
+               di->inst_id, output_type, proto_id);
 
-       if (!(pdo = g_try_malloc(sizeof(struct srd_pd_output))))
+       if (!(pdo = g_try_malloc(sizeof(struct srd_pd_output)))) {
+               srd_err("Failed to g_malloc() struct srd_pd_output.");
                return -1;
+       }
 
        /* pdo_id is just a simple index, nothing is deleted from this list anyway. */
        pdo->pdo_id = g_slist_length(di->pd_output);
@@ -746,4 +796,3 @@ int pd_add(struct srd_decoder_instance *di, int output_type, char *proto_id)
 
        return pdo->pdo_id;
 }
-