srd: don't check directory structure a PD is in, but what it implements.
[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_method, *py_annlist, *py_ann;
79         struct srd_decoder *d;
80         int alen, ret, i;
81         char **ann;
82
83         py_basedec = py_method = NULL;
84
85         srd_dbg("decoder: %s: loading module '%s'", __func__, name);
86
87         if (!(d = g_try_malloc0(sizeof(struct srd_decoder)))) {
88                 srd_err("decoder: %s: d malloc failed", __func__);
89                 ret = SRD_ERR_MALLOC;
90                 goto err_out;
91         }
92
93         ret = SRD_ERR_PYTHON;
94
95         /* Import the Python module. */
96         if (!(d->py_mod = PyImport_ImportModule(name))) {
97                 /* TODO: Report exception message/traceback to err/dbg. */
98                 srd_warn("decoder: %s: import of '%s' failed", __func__, name);
99                 PyErr_Print();
100                 PyErr_Clear();
101                 goto err_out;
102         }
103
104         /* Get the 'Decoder' class as Python object. */
105         if (!(d->py_dec = PyObject_GetAttrString(d->py_mod, "Decoder"))) {
106                 /* This generated an AttributeError exception. */
107                 PyErr_Print();
108                 PyErr_Clear();
109                 srd_err("Decoder class not found in protocol decoder %s", name);
110                 goto err_out;
111         }
112
113         if (!(py_basedec = PyObject_GetAttrString(mod_sigrokdecode, "Decoder"))) {
114                 srd_dbg("sigrokdecode module not loaded");
115                 goto err_out;
116         }
117
118         if (!PyObject_IsSubclass(d->py_dec, py_basedec)) {
119                 srd_err("Decoder class in protocol decoder module %s is not "
120                                 "a subclass of sigrokdecode.Decoder", name);
121                 goto err_out;
122         }
123         Py_DecRef(py_basedec);
124
125         /* Check for a proper start() method. */
126         if (!PyObject_HasAttrString(d->py_dec, "start")) {
127                 srd_err("Protocol decoder %s has no start() method Decoder "
128                                 "class.", name);
129                 goto err_out;
130         }
131         py_method = PyObject_GetAttrString(d->py_dec, "start");
132         if (!PyFunction_Check(py_method)) {
133                 srd_err("Protocol decoder %s Decoder class attribute 'start'"
134                                 "is not a method.", name);
135                 goto err_out;
136         }
137         Py_DecRef(py_method);
138
139         /* Check for a proper decode() method. */
140         if (!PyObject_HasAttrString(d->py_dec, "decode")) {
141                 srd_err("Protocol decoder %s has no decode() method Decoder "
142                                 "class.", name);
143                 goto err_out;
144         }
145         py_method = PyObject_GetAttrString(d->py_dec, "decode");
146         if (!PyFunction_Check(py_method)) {
147                 srd_err("Protocol decoder %s Decoder class attribute 'decode' "
148                                 "is not a method.", name);
149                 goto err_out;
150         }
151         Py_DecRef(py_method);
152
153         if (py_attr_as_str(d->py_dec, "id", &(d->id)) != SRD_OK)
154                 goto err_out;
155
156         if (py_attr_as_str(d->py_dec, "name", &(d->name)) != SRD_OK)
157                 goto err_out;
158
159         if (py_attr_as_str(d->py_dec, "longname", &(d->longname)) != SRD_OK)
160                 goto err_out;
161
162         if (py_attr_as_str(d->py_dec, "desc", &(d->desc)) != SRD_OK)
163                 goto err_out;
164
165         if (py_attr_as_str(d->py_dec, "license", &(d->license)) != SRD_OK)
166                 goto err_out;
167
168         /* TODO: Handle inputformats, outputformats. */
169         d->inputformats = NULL;
170         d->outputformats = NULL;
171
172         /* Convert class annotation attribute to GSList of **char */
173         d->annotations = NULL;
174         if (PyObject_HasAttrString(d->py_dec, "annotations")) {
175                 py_annlist = PyObject_GetAttrString(d->py_dec, "annotations");
176                 if (!PyList_Check(py_annlist)) {
177                         srd_err("Protocol decoder module %s annotations should be a list", name);
178                         goto err_out;
179                 }
180                 alen = PyList_Size(py_annlist);
181                 for (i = 0; i < alen; i++) {
182                         py_ann = PyList_GetItem(py_annlist, i);
183                         if (!PyList_Check(py_ann) || PyList_Size(py_ann) != 2) {
184                                 srd_err("Protocol decoder module %s annotation %d should be a list with two elements",
185                                                 name, i+1);
186                                 goto err_out;
187                         }
188
189                         if (py_strlist_to_char(py_ann, &ann) != SRD_OK) {
190                                 goto err_out;
191                         }
192                         d->annotations = g_slist_append(d->annotations, ann);
193                 }
194         }
195
196         *dec = d;
197         ret = SRD_OK;
198
199 err_out:
200         if (ret != SRD_OK) {
201                 Py_XDECREF(py_method);
202                 Py_XDECREF(py_basedec);
203                 Py_XDECREF(d->py_dec);
204                 Py_XDECREF(d->py_mod);
205                 g_free(d);
206         }
207
208         return ret;
209 }
210
211 char *srd_decoder_doc(struct srd_decoder *dec)
212 {
213         PyObject *py_str;
214         char *doc;
215
216         if (!PyObject_HasAttrString(dec->py_mod, "__doc__"))
217                 return NULL;
218
219         if (!(py_str = PyObject_GetAttrString(dec->py_mod, "__doc__"))) {
220                 PyErr_Clear();
221                 return NULL;
222         }
223
224         doc = NULL;
225         if (py_str != Py_None)
226                 py_str_as_str(py_str, &doc);
227         Py_DecRef(py_str);
228
229         return doc;
230 }
231
232
233 /**
234  * Unload decoder module.
235  *
236  * @param dec The decoder struct to be unloaded.
237  *
238  * @return SRD_OK upon success, a (negative) error code otherwise.
239  */
240 int srd_unload_decoder(struct srd_decoder *dec)
241 {
242
243         g_free(dec->id);
244         g_free(dec->name);
245         g_free(dec->longname);
246         g_free(dec->desc);
247         g_free(dec->license);
248
249         /* TODO: Free everything in inputformats and outputformats. */
250         if (dec->inputformats != NULL)
251                 g_slist_free(dec->inputformats);
252         if (dec->outputformats != NULL)
253                 g_slist_free(dec->outputformats);
254
255         Py_XDECREF(dec->py_dec);
256         Py_XDECREF(dec->py_mod);
257
258         /* TODO: (g_)free dec itself? */
259
260         return SRD_OK;
261 }
262
263 int srd_load_all_decoders(void)
264 {
265         DIR *dir;
266         struct dirent *dp;
267         int ret;
268         char *decodername;
269         struct srd_decoder *dec;
270
271         if (!(dir = opendir(DECODERS_DIR))) {
272                 Py_Finalize(); /* Returns void. */
273                 return SRD_ERR_DECODERS_DIR;
274         }
275
276         while ((dp = readdir(dir)) != NULL) {
277                 /* Ignore filenames which don't end with ".py". */
278                 if (!g_str_has_suffix(dp->d_name, ".py"))
279                         continue;
280
281                 /* The decoder name is the PD directory name (e.g. "i2c"). */
282                 decodername = g_strndup(dp->d_name, strlen(dp->d_name) - 3);
283
284                 /* TODO: Error handling. Use g_try_malloc(). */
285                 if (!(dec = malloc(sizeof(struct srd_decoder)))) {
286                         Py_Finalize(); /* Returns void. */
287                         return SRD_ERR_MALLOC;
288                 }
289
290                 /* Load the decoder. */
291                 /* TODO: Warning if loading fails for a decoder. */
292                 if ((ret = srd_load_decoder(decodername, &dec)) == SRD_OK) {
293                         /* Append it to the list of supported/loaded decoders. */
294                         pd_list = g_slist_append(pd_list, dec);
295                 }
296         }
297         closedir(dir);
298
299         return SRD_OK;
300 }
301
302 /**
303  * TODO
304  */
305 int srd_unload_all_decoders(void)
306 {
307         GSList *l;
308         struct srd_decoder *dec;
309
310         for (l = srd_list_decoders(); l; l = l->next) {
311                 dec = l->data;
312                 /* TODO: Error handling. */
313                 srd_unload_decoder(dec);
314         }
315
316         return SRD_OK;
317 }
318
319
320