8d0bbe5da8df7803c1f74855db7e26617d843897
[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 char *strcanon(const char *str)
130 {
131         int p0, p1;
132         char *s;
133
134         /* Returns newly allocated string. */
135         s = g_ascii_strdown(str, -1);
136         for (p0 = p1 = 0; str[p0]; p0++) {
137                 if ((s[p0] >= 'a' && s[p0] <= 'z')
138                                 || (s[p0] >= '0' && s[p0] <= '9'))
139                         s[p1++] = s[p0];
140         }
141         s[p1] = '\0';
142
143         return s;
144 }
145
146 int canon_cmp(const char *str1, const char *str2)
147 {
148         int ret;
149         char *s1, *s2;
150
151         s1 = strcanon(str1);
152         s2 = strcanon(str2);
153         ret = g_ascii_strcasecmp(s1, s2);
154         g_free(s2);
155         g_free(s1);
156
157         return ret;
158 }