]> sigrok.org Git - libsigrok.git/blob - strutil.c
sr: g_free()/g_string_free() can handle NULL input.
[libsigrok.git] / strutil.c
1 /*
2  * This file is part of the sigrok project.
3  *
4  * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
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 2 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, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
19  */
20
21 #include <stdint.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include "sigrok.h"
25 #include "sigrok-internal.h"
26
27 /**
28  * Convert a numeric samplerate value to its "natural" string representation.
29  *
30  * E.g. a value of 3000000 would be converted to "3 MHz", 20000 to "20 kHz".
31  *
32  * @param samplerate The samplerate in Hz.
33  * @return A malloc()ed string representation of the samplerate value,
34  *         or NULL upon errors. The caller is responsible to free() the memory.
35  */
36 char *sr_samplerate_string(uint64_t samplerate)
37 {
38         char *o;
39         int r;
40
41         o = malloc(30 + 1); /* Enough for a uint64_t as string + " GHz". */
42         if (!o)
43                 return NULL;
44
45         if (samplerate >= SR_GHZ(1))
46                 r = snprintf(o, 30, "%" PRIu64 " GHz", samplerate / 1000000000);
47         else if (samplerate >= SR_MHZ(1))
48                 r = snprintf(o, 30, "%" PRIu64 " MHz", samplerate / 1000000);
49         else if (samplerate >= SR_KHZ(1))
50                 r = snprintf(o, 30, "%" PRIu64 " kHz", samplerate / 1000);
51         else
52                 r = snprintf(o, 30, "%" PRIu64 " Hz", samplerate);
53
54         if (r < 0) {
55                 /* Something went wrong... */
56                 free(o);
57                 return NULL;
58         }
59
60         return o;
61 }
62
63 /**
64  * Convert a numeric frequency value to the "natural" string representation
65  * of its period.
66  *
67  * E.g. a value of 3000000 would be converted to "3 us", 20000 to "50 ms".
68  *
69  * @param frequency The frequency in Hz.
70  * @return A malloc()ed string representation of the frequency value,
71  *         or NULL upon errors. The caller is responsible to free() the memory.
72  */
73 char *sr_period_string(uint64_t frequency)
74 {
75         char *o;
76         int r;
77
78         o = malloc(30 + 1); /* Enough for a uint64_t as string + " ms". */
79         if (!o)
80                 return NULL;
81
82         if (frequency >= SR_GHZ(1))
83                 r = snprintf(o, 30, "%" PRIu64 " ns", frequency / 1000000000);
84         else if (frequency >= SR_MHZ(1))
85                 r = snprintf(o, 30, "%" PRIu64 " us", frequency / 1000000);
86         else if (frequency >= SR_KHZ(1))
87                 r = snprintf(o, 30, "%" PRIu64 " ms", frequency / 1000);
88         else
89                 r = snprintf(o, 30, "%" PRIu64 " s", frequency);
90
91         if (r < 0) {
92                 /* Something went wrong... */
93                 free(o);
94                 return NULL;
95         }
96
97         return o;
98 }
99
100 /**
101  * TODO
102  *
103  * @param device TODO
104  * @param triggerstring TODO
105  * @return TODO
106  */
107 char **sr_parse_triggerstring(struct sr_device *device,
108                               const char *triggerstring)
109 {
110         GSList *l;
111         struct sr_probe *probe;
112         int max_probes, probenum, i;
113         char **tokens, **triggerlist, *trigger, *tc, *trigger_types;
114         gboolean error;
115
116         max_probes = g_slist_length(device->probes);
117         error = FALSE;
118
119         if (!(triggerlist = g_try_malloc0(max_probes * sizeof(char *)))) {
120                 sr_err("session file: %s: metafile malloc failed", __func__);
121                 return NULL;
122         }
123
124         tokens = g_strsplit(triggerstring, ",", max_probes);
125         trigger_types = device->plugin->get_device_info(0, SR_DI_TRIGGER_TYPES);
126         if (trigger_types == NULL)
127                 return NULL;
128
129         for (i = 0; tokens[i]; i++) {
130                 if (tokens[i][0] < '0' || tokens[i][0] > '9') {
131                         /* Named probe */
132                         probenum = 0;
133                         for (l = device->probes; l; l = l->next) {
134                                 probe = (struct sr_probe *)l->data;
135                                 if (probe->enabled
136                                     && !strncmp(probe->name, tokens[i],
137                                                 strlen(probe->name))) {
138                                         probenum = probe->index;
139                                         break;
140                                 }
141                         }
142                 } else {
143                         probenum = strtol(tokens[i], NULL, 10);
144                 }
145
146                 if (probenum < 1 || probenum > max_probes) {
147                         sr_err("Invalid probe.\n");
148                         error = TRUE;
149                         break;
150                 }
151
152                 if ((trigger = strchr(tokens[i], '='))) {
153                         for (tc = ++trigger; *tc; tc++) {
154                                 if (strchr(trigger_types, *tc) == NULL) {
155                                         sr_err("Unsupported trigger type "
156                                                "'%c'\n", *tc);
157                                         error = TRUE;
158                                         break;
159                                 }
160                         }
161                         if (!error)
162                                 triggerlist[probenum - 1] = g_strdup(trigger);
163                 }
164         }
165         g_strfreev(tokens);
166
167         if (error) {
168                 for (i = 0; i < max_probes; i++)
169                         g_free(triggerlist[i]);
170                 g_free(triggerlist);
171                 triggerlist = NULL;
172         }
173
174         return triggerlist;
175 }
176
177 /**
178  * Convert a "natural" string representation of a size value to uint64_t.
179  *
180  * E.g. a value of "3k" or "3 K" would be converted to 3000, a value
181  * of "15M" would be converted to 15000000.
182  *
183  * Value representations other than decimal (such as hex or octal) are not
184  * supported. Only 'k' (kilo), 'm' (mega), 'g' (giga) suffixes are supported.
185  * Spaces (but not other whitespace) between value and suffix are allowed.
186  *
187  * @param sizestring A string containing a (decimal) size value.
188  * @param size Pointer to uint64_t which will contain the string's size value.
189  * @return SR_OK or error code
190  *
191  */
192 int sr_parse_sizestring(const char *sizestring, uint64_t *size)
193 {
194         int multiplier, done;
195         char *s;
196
197         *size = strtoull(sizestring, &s, 10);
198         multiplier = 0;
199         done = FALSE;
200         while (s && *s && multiplier == 0 && !done) {
201                 switch (*s) {
202                 case ' ':
203                         break;
204                 case 'k':
205                 case 'K':
206                         multiplier = SR_KHZ(1);
207                         break;
208                 case 'm':
209                 case 'M':
210                         multiplier = SR_MHZ(1);
211                         break;
212                 case 'g':
213                 case 'G':
214                         multiplier = SR_GHZ(1);
215                         break;
216                 default:
217                         done = TRUE;
218                         s--;
219                 }
220                 s++;
221         }
222         if (multiplier > 0)
223                 *size *= multiplier;
224
225         if (*s && strcasecmp(s, "Hz"))
226                 return SR_ERR;
227
228         return SR_OK;
229 }
230
231 /**
232  * Convert a "natural" string representation of a time value to an
233  * uint64_t value in milliseconds.
234  *
235  * E.g. a value of "3s" or "3 s" would be converted to 3000, a value
236  * of "15ms" would be converted to 15.
237  *
238  * Value representations other than decimal (such as hex or octal) are not
239  * supported. Only lower-case "s" and "ms" time suffixes are supported.
240  * Spaces (but not other whitespace) between value and suffix are allowed.
241  *
242  * @param timestring A string containing a (decimal) time value.
243  * @return The string's time value as uint64_t, in milliseconds.
244  *
245  * TODO: Error handling.
246  * TODO: Add support for "m" (minutes) and others.
247  * TODO: picoseconds?
248  * TODO: Allow both lower-case and upper-case.
249  */
250 uint64_t sr_parse_timestring(const char *timestring)
251 {
252         uint64_t time_msec;
253         char *s;
254
255         time_msec = strtoull(timestring, &s, 10);
256         if (time_msec == 0 && s == timestring)
257                 return 0;
258
259         if (s && *s) {
260                 while (*s == ' ')
261                         s++;
262                 if (!strcmp(s, "s"))
263                         time_msec *= 1000;
264                 else if (!strcmp(s, "ms"))
265                         ; /* redundant */
266                 else
267                         return 0;
268         }
269
270         return time_msec;
271 }
272
273 gboolean sr_parse_boolstring(const char *boolstr)
274 {
275         if (!boolstr)
276                 return FALSE;
277
278         if (!g_strcasecmp(boolstr, "true") || 
279             !g_strcasecmp(boolstr, "yes") ||
280             !g_strcasecmp(boolstr, "on") ||
281             !g_strcasecmp(boolstr, "1")) 
282                 return TRUE;
283
284         return FALSE;
285 }