cli: more flexible generic arg parser
[sigrok-cli.git] / parsers.c
1 /*
2  * This file is part of the sigrok project.
3  *
4  * Copyright (C) 2011 Bert Vermeulen <bert@biot.com>
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <stdint.h>
23 #include <string.h>
24 #include <glib.h>
25 #include <libsigrok/libsigrok.h>
26 #include "sigrok-cli.h"
27
28 char **parse_probestring(int max_probes, const char *probestring)
29 {
30         int tmp, b, e, i;
31         char **tokens, **range, **probelist, *name, str[8];
32         gboolean error;
33
34         error = FALSE;
35         range = NULL;
36         if (!(probelist = g_try_malloc0(max_probes * sizeof(char *)))) {
37                 /* TODO: Handle errors. */
38         }
39         tokens = g_strsplit(probestring, ",", max_probes);
40
41         for (i = 0; tokens[i]; i++) {
42                 if (strchr(tokens[i], '-')) {
43                         /* A range of probes in the form 1-5. */
44                         range = g_strsplit(tokens[i], "-", 2);
45                         if (!range[0] || !range[1] || range[2]) {
46                                 /* Need exactly two arguments. */
47                                 g_critical("Invalid probe syntax '%s'.", tokens[i]);
48                                 error = TRUE;
49                                 break;
50                         }
51
52                         b = strtol(range[0], NULL, 10);
53                         e = strtol(range[1], NULL, 10);
54                         if (b < 1 || e > max_probes || b >= e) {
55                                 g_critical("Invalid probe range '%s'.", tokens[i]);
56                                 error = TRUE;
57                                 break;
58                         }
59
60                         while (b <= e) {
61                                 snprintf(str, 7, "%d", b);
62                                 probelist[b - 1] = g_strdup(str);
63                                 b++;
64                         }
65                 } else {
66                         tmp = strtol(tokens[i], NULL, 10);
67                         if (tmp < 1 || tmp > max_probes) {
68                                 g_critical("Invalid probe %d.", tmp);
69                                 error = TRUE;
70                                 break;
71                         }
72
73                         if ((name = strchr(tokens[i], '='))) {
74                                 probelist[tmp - 1] = g_strdup(++name);
75                                 if (strlen(probelist[tmp - 1]) > SR_MAX_PROBENAME_LEN)
76                                         probelist[tmp - 1][SR_MAX_PROBENAME_LEN] = 0;
77                         } else {
78                                 snprintf(str, 7, "%d", tmp);
79                                 probelist[tmp - 1] = g_strdup(str);
80                         }
81                 }
82         }
83
84         if (error) {
85                 for (i = 0; i < max_probes; i++)
86                         if (probelist[i])
87                                 g_free(probelist[i]);
88                 g_free(probelist);
89                 probelist = NULL;
90         }
91
92         g_strfreev(tokens);
93         if (range)
94                 g_strfreev(range);
95
96         return probelist;
97 }
98
99 GHashTable *parse_generic_arg(const char *arg, gboolean sep_first)
100 {
101         GHashTable *hash;
102         int i;
103         char **elements, *e;
104
105         if (!arg || !arg[0])
106                 return NULL;
107
108         i = 0;
109         hash = g_hash_table_new_full(g_str_hash, g_str_equal,
110                         g_free, g_free);
111         elements = g_strsplit(arg, ":", 0);
112         if (sep_first)
113                 g_hash_table_insert(hash, g_strdup("sigrok_key"),
114                                 g_strdup(elements[i++]));
115         for (; elements[i]; i++) {
116                 e = strchr(elements[i], '=');
117                 if (!e)
118                         g_hash_table_insert(hash, g_strdup(elements[i]), NULL);
119                 else {
120                         *e++ = '\0';
121                         g_hash_table_insert(hash, g_strdup(elements[i]), g_strdup(e));
122                 }
123         }
124         g_strfreev(elements);
125
126         return hash;
127 }
128
129 struct sr_dev *parse_devstring(const char *devstring)
130 {
131         struct sr_dev *dev, *d;
132         struct sr_dev_driver **drivers;
133         GSList *devs, *l;
134         int i, num_devs, dev_num, dev_cnt;
135         char *tmp;
136
137         if (!devstring)
138                 return NULL;
139
140         dev = NULL;
141         dev_num = strtol(devstring, &tmp, 10);
142         if (tmp != devstring) {
143                 /* argument is numeric, meaning a device ID. Make all drivers
144                  * scan for devices.
145                  */
146                 num_devs = num_real_devs();
147                 if (dev_num < 0 || dev_num >= num_devs)
148                         return NULL;
149
150                 dev_cnt = 0;
151                 devs = sr_dev_list();
152                 for (l = devs; l; l = l->next) {
153                         d = l->data;
154                         if (sr_dev_has_hwcap(d, SR_HWCAP_DEMO_DEV))
155                                 continue;
156                         if (dev_cnt == dev_num) {
157                                 if (dev_num == dev_cnt) {
158                                         dev = d;
159                                         break;
160                                 }
161                         }
162                         dev_cnt++;
163                 }
164         } else {
165                 /* select device by driver -- only initialize that driver,
166                  * no need to let them all scan
167                  */
168                 dev = NULL;
169                 drivers = sr_driver_list();
170                 for (i = 0; drivers[i]; i++) {
171                         if (strcmp(drivers[i]->name, devstring))
172                                 continue;
173                         num_devs = sr_driver_init(drivers[i]);
174                         if (num_devs == 1) {
175                                 devs = sr_dev_list();
176                                 dev = devs->data;
177                         } else if (num_devs > 1) {
178                                 printf("driver '%s' found %d devices, select by ID instead.\n",
179                                                 devstring, num_devs);
180                         }
181                         /* fall through: selected driver found no devices */
182                         break;
183                 }
184         }
185
186         return dev;
187 }
188
189 char *strcanon(const char *str)
190 {
191         int p0, p1;
192         char *s;
193
194         /* Returns newly allocated string. */
195         s = g_ascii_strdown(str, -1);
196         for (p0 = p1 = 0; str[p0]; p0++) {
197                 if ((s[p0] >= 'a' && s[p0] <= 'z')
198                                 || (s[p0] >= '0' && s[p0] <= '9'))
199                         s[p1++] = s[p0];
200         }
201         s[p1] = '\0';
202
203         return s;
204 }
205
206 int canon_cmp(const char *str1, const char *str2)
207 {
208         int ret;
209         char *s1, *s2;
210
211         s1 = strcanon(str1);
212         s2 = strcanon(str2);
213         ret = g_ascii_strcasecmp(s1, s2);
214         g_free(s2);
215         g_free(s1);
216
217         return ret;
218 }