cli: only output module or PD goes to stdout, everything else to stderr
[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 <sigrok.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)
100 {
101         GHashTable *hash;
102         int i;
103         char **elements, *e;
104
105         if (!arg || !arg[0])
106                 return NULL;
107
108         hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
109         elements = g_strsplit(arg, ":", 0);
110         g_hash_table_insert(hash, g_strdup("sigrok_key"), g_strdup(elements[0]));
111         for (i = 1; elements[i]; i++) {
112                 e = strchr(elements[i], '=');
113                 if (!e)
114                         g_hash_table_insert(hash, g_strdup(elements[i]), NULL);
115                 else {
116                         *e++ = '\0';
117                         g_hash_table_insert(hash, g_strdup(elements[i]), g_strdup(e));
118                 }
119         }
120         g_strfreev(elements);
121
122         return hash;
123 }
124
125 struct sr_dev *parse_devstring(const char *devstring)
126 {
127         struct sr_dev *dev, *d;
128         struct sr_dev_driver **drivers;
129         GSList *devs, *l;
130         int i, num_devs, dev_num, dev_cnt;
131         char *tmp;
132
133         if (!devstring)
134                 return NULL;
135
136         dev = NULL;
137         dev_num = strtol(devstring, &tmp, 10);
138         if (tmp != devstring) {
139                 /* argument is numeric, meaning a device ID. Make all drivers
140                  * scan for devices.
141                  */
142                 num_devs = num_real_devs();
143                 if (dev_num < 0 || dev_num >= num_devs)
144                         return NULL;
145
146                 dev_cnt = 0;
147                 devs = sr_dev_list();
148                 for (l = devs; l; l = l->next) {
149                         d = l->data;
150                         if (sr_dev_has_hwcap(d, SR_HWCAP_DEMO_DEV))
151                                 continue;
152                         if (dev_cnt == dev_num) {
153                                 if (dev_num == dev_cnt) {
154                                         dev = d;
155                                         break;
156                                 }
157                         }
158                         dev_cnt++;
159                 }
160         } else {
161                 /* select device by driver -- only initialize that driver,
162                  * no need to let them all scan
163                  */
164                 dev = NULL;
165                 drivers = sr_driver_list();
166                 for (i = 0; drivers[i]; i++) {
167                         if (strcmp(drivers[i]->name, devstring))
168                                 continue;
169                         num_devs = sr_driver_init(drivers[i]);
170                         if (num_devs == 1) {
171                                 devs = sr_dev_list();
172                                 dev = devs->data;
173                         } else if (num_devs > 1) {
174                                 printf("driver '%s' found %d devices, select by ID instead.\n",
175                                                 devstring, num_devs);
176                         }
177                         /* fall through: selected driver found no devices */
178                         break;
179                 }
180         }
181
182         return dev;
183 }