srd: clean up module loading/unloading, and the decoder struct
[libsigrokdecode.git] / decoder.c
1 /*
2  * This file is part of the sigrok project.
3  *
4  * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
5  * Copyright (C) 2011 Bert Vermeulen <bert@biot.com>
6  *
7  * This program is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation, either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include "config.h"
22 #include "sigrokdecode.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */
23 #include "sigrokdecode-internal.h"
24 #include <dirent.h>
25
26 /* The list of protocol decoders. */
27 GSList *pd_list = NULL;
28
29 /* lives in module_sigrokdecode.c */
30 extern PyObject *mod_sigrokdecode;
31
32
33 /**
34  * Returns the list of supported/loaded protocol decoders.
35  *
36  * This is a GSList containing the names of the decoders as strings.
37  *
38  * @return List of decoders, NULL if none are supported or loaded.
39  */
40 GSList *srd_list_decoders(void)
41 {
42
43         return pd_list;
44 }
45
46
47 /**
48  * Get the decoder with the specified ID.
49  *
50  * @param id The ID string of the decoder to return.
51  * @return The decoder with the specified ID, or NULL if not found.
52  */
53 struct srd_decoder *srd_get_decoder_by_id(const char *id)
54 {
55         GSList *l;
56         struct srd_decoder *dec;
57
58         for (l = srd_list_decoders(); l; l = l->next) {
59                 dec = l->data;
60                 if (!strcmp(dec->id, id))
61                         return dec;
62         }
63
64         return NULL;
65 }
66
67
68 /**
69  * Load a protocol decoder module into the embedded python interpreter.
70  *
71  * @param name The module name to be loaded.
72  * @param dec Pointer to the struct srd_decoder filled with the loaded module.
73  *
74  * @return SRD_OK upon success, a (negative) error code otherwise.
75  */
76 int srd_load_decoder(const char *name, struct srd_decoder **dec)
77 {
78         PyObject *py_basedec, *py_annlist, *py_ann;
79         struct srd_decoder *d;
80         int alen, ret, i;
81         char **ann;
82
83         py_basedec = NULL;
84         ret = SRD_ERR;
85         srd_dbg("loading module %s", name);
86
87         if (!(d = g_try_malloc0(sizeof(struct srd_decoder)))) {
88                 ret = SRD_ERR_MALLOC;
89                 goto err_out;
90         }
91
92         /* Import the Python module. */
93         if (!(d->py_mod = PyImport_ImportModule(name))) {
94                 /* TODO: report exception message/traceback to err/dbg */
95                 srd_dbg("import failed");
96                 PyErr_Clear();
97                 ret = SRD_ERR_PYTHON;
98                 goto err_out;
99         }
100
101         /* Get the 'Decoder' class as Python object. */
102         if (!(d->py_dec = PyObject_GetAttrString(d->py_mod, "Decoder"))) {
103                 /* This generated an AttributeError exception. */
104                 PyErr_Clear();
105                 srd_err("Decoder class not found in protocol decoder module %s", name);
106                 ret = SRD_ERR_PYTHON;
107                 goto err_out;
108         }
109
110         if (!(py_basedec = PyObject_GetAttrString(mod_sigrokdecode, "Decoder"))) {
111                 srd_dbg("sigrokdecode module not loaded");
112                 ret = SRD_ERR_PYTHON;
113                 goto err_out;
114         }
115
116         if (!PyObject_IsSubclass(d->py_dec, py_basedec)) {
117                 srd_err("Decoder class in protocol decoder module %s is not "
118                                 "a subclass of sigrokdecode.Decoder", name);
119                 ret = SRD_ERR_PYTHON;
120                 goto err_out;
121         }
122         Py_DecRef(py_basedec);
123
124         if (py_attr_as_str(d->py_dec, "id", &(d->id)) != SRD_OK) {
125                 return SRD_ERR_PYTHON;
126                 goto err_out;
127         }
128
129         if (py_attr_as_str(d->py_dec, "name", &(d->name)) != SRD_OK) {
130                 return SRD_ERR_PYTHON;
131                 goto err_out;
132         }
133
134         if (py_attr_as_str(d->py_dec, "longname", &(d->longname)) != SRD_OK) {
135                 return SRD_ERR_PYTHON;
136                 goto err_out;
137         }
138
139         if (py_attr_as_str(d->py_dec, "desc", &(d->desc)) != SRD_OK) {
140                 return SRD_ERR_PYTHON;
141                 goto err_out;
142         }
143
144         if (py_attr_as_str(d->py_dec, "license", &(d->license)) != SRD_OK) {
145                 return SRD_ERR_PYTHON;
146                 goto err_out;
147         }
148
149         /* TODO: Handle inputformats, outputformats. */
150         d->inputformats = NULL;
151         d->outputformats = NULL;
152
153         /* Convert class annotation attribute to GSList of **char */
154         d->annotations = NULL;
155         if (PyObject_HasAttrString(d->py_dec, "annotations")) {
156                 py_annlist = PyObject_GetAttrString(d->py_dec, "annotations");
157                 if (!PyList_Check(py_annlist)) {
158                         srd_err("Protocol decoder module %s annotations should be a list", name);
159                         ret = SRD_ERR_PYTHON;
160                         goto err_out;
161                 }
162                 alen = PyList_Size(py_annlist);
163                 for (i = 0; i < alen; i++) {
164                         py_ann = PyList_GetItem(py_annlist, i);
165                         if (!PyList_Check(py_ann) || PyList_Size(py_ann) != 2) {
166                                 srd_err("Protocol decoder module %s annotation %d should be a list with two elements",
167                                                 name, i+1);
168                                 ret = SRD_ERR_PYTHON;
169                                 goto err_out;
170                         }
171
172                         if (py_strlist_to_char(py_ann, &ann) != SRD_OK) {
173                                 ret = SRD_ERR_PYTHON;
174                                 goto err_out;
175                         }
176                         d->annotations = g_slist_append(d->annotations, ann);
177                 }
178         }
179
180         *dec = d;
181         ret = SRD_OK;
182
183 err_out:
184         if (ret != SRD_OK) {
185                 Py_XDECREF(py_basedec);
186                 Py_XDECREF(d->py_dec);
187                 Py_XDECREF(d->py_mod);
188                 g_free(d);
189         }
190
191         return ret;
192 }
193
194 char *srd_decoder_doc(struct srd_decoder *dec)
195 {
196         char *doc;
197
198         doc = NULL;
199         py_attr_as_str(dec->py_mod, "__doc__", &doc);
200
201         return doc;
202 }
203
204
205 /**
206  * Unload decoder module.
207  *
208  * @param dec The decoder struct to be unloaded.
209  *
210  * @return SRD_OK upon success, a (negative) error code otherwise.
211  */
212 int srd_unload_decoder(struct srd_decoder *dec)
213 {
214
215         g_free(dec->id);
216         g_free(dec->name);
217         g_free(dec->longname);
218         g_free(dec->desc);
219         g_free(dec->license);
220
221         /* TODO: Free everything in inputformats and outputformats. */
222         if (dec->inputformats != NULL)
223                 g_slist_free(dec->inputformats);
224         if (dec->outputformats != NULL)
225                 g_slist_free(dec->outputformats);
226
227         Py_XDECREF(dec->py_dec);
228         Py_XDECREF(dec->py_mod);
229
230         /* TODO: (g_)free dec itself? */
231
232         return SRD_OK;
233 }
234
235
236 int srd_load_all_decoders(void)
237 {
238         DIR *dir;
239         struct dirent *dp;
240         int ret;
241         char *decodername;
242         struct srd_decoder *dec;
243
244         if (!(dir = opendir(DECODERS_DIR))) {
245                 Py_Finalize(); /* Returns void. */
246                 return SRD_ERR_DECODERS_DIR;
247         }
248
249         while ((dp = readdir(dir)) != NULL) {
250                 /* Ignore filenames which don't end with ".py". */
251                 if (!g_str_has_suffix(dp->d_name, ".py"))
252                         continue;
253
254                 /* Decoder name == filename (without .py suffix). */
255                 decodername = g_strndup(dp->d_name, strlen(dp->d_name) - 3);
256
257                 /* TODO: Error handling. Use g_try_malloc(). */
258                 if (!(dec = malloc(sizeof(struct srd_decoder)))) {
259                         Py_Finalize(); /* Returns void. */
260                         return SRD_ERR_MALLOC;
261                 }
262
263                 /* Load the decoder. */
264                 /* TODO: Warning if loading fails for a decoder. */
265                 if ((ret = srd_load_decoder(decodername, &dec)) == SRD_OK) {
266                         /* Append it to the list of supported/loaded decoders. */
267                         pd_list = g_slist_append(pd_list, dec);
268                 }
269         }
270         closedir(dir);
271
272         return SRD_OK;
273 }
274
275
276 /**
277  * TODO
278  */
279 int srd_unload_all_decoders(void)
280 {
281         GSList *l;
282         struct srd_decoder *dec;
283
284         for (l = srd_list_decoders(); l; l = l->next) {
285                 dec = l->data;
286                 /* TODO: Error handling. */
287                 srd_unload_decoder(dec);
288         }
289
290         return SRD_OK;
291 }
292
293
294