blob: 59eb5dc4e3b5b25075fcbdac9900c58c9fae2f8c [file] [log] [blame]
Paolo Bonzinia020f982012-02-09 09:36:37 +01001/*
2 * String parsing visitor
3 *
Eric Blake08f95412016-01-29 06:48:59 -07004 * Copyright Red Hat, Inc. 2012-2016
Paolo Bonzinia020f982012-02-09 09:36:37 +01005 *
6 * Author: Paolo Bonzini <pbonzini@redhat.com>
7 *
8 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
9 * See the COPYING.LIB file in the top-level directory.
10 *
11 */
12
Peter Maydellcbf21152016-01-29 17:49:57 +000013#include "qemu/osdep.h"
Paolo Bonzinia020f982012-02-09 09:36:37 +010014#include "qemu-common.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010015#include "qapi/string-input-visitor.h"
16#include "qapi/visitor-impl.h"
17#include "qapi/qmp/qerror.h"
Paolo Bonzinia5829cc2014-02-08 11:01:44 +010018#include "qemu/option.h"
Hu Tao659268f2014-06-10 19:15:27 +080019#include "qemu/queue.h"
20#include "qemu/range.h"
21
Paolo Bonzinia020f982012-02-09 09:36:37 +010022
23struct StringInputVisitor
24{
25 Visitor visitor;
Hu Tao659268f2014-06-10 19:15:27 +080026
27 bool head;
28
29 GList *ranges;
30 GList *cur_range;
31 int64_t cur;
32
Paolo Bonzinia020f982012-02-09 09:36:37 +010033 const char *string;
34};
35
Eric Blaked7bea752016-01-29 06:48:38 -070036static StringInputVisitor *to_siv(Visitor *v)
37{
38 return container_of(v, StringInputVisitor, visitor);
39}
40
Michael S. Tsirkin0d156682014-06-16 18:07:03 +030041static void free_range(void *range, void *dummy)
42{
43 g_free(range);
44}
45
Hu Tao659268f2014-06-10 19:15:27 +080046static void parse_str(StringInputVisitor *siv, Error **errp)
47{
48 char *str = (char *) siv->string;
49 long long start, end;
50 Range *cur;
51 char *endptr;
52
53 if (siv->ranges) {
54 return;
55 }
56
Hu Tao659268f2014-06-10 19:15:27 +080057 do {
Michael S. Tsirkinc210ee92014-06-18 17:50:07 +030058 errno = 0;
Hu Tao659268f2014-06-10 19:15:27 +080059 start = strtoll(str, &endptr, 0);
Michael S. Tsirkinc210ee92014-06-18 17:50:07 +030060 if (errno == 0 && endptr > str) {
Hu Tao659268f2014-06-10 19:15:27 +080061 if (*endptr == '\0') {
62 cur = g_malloc0(sizeof(*cur));
63 cur->begin = start;
64 cur->end = start + 1;
65 siv->ranges = g_list_insert_sorted_merged(siv->ranges, cur,
66 range_compare);
67 cur = NULL;
68 str = NULL;
69 } else if (*endptr == '-') {
70 str = endptr + 1;
Michael S. Tsirkinc210ee92014-06-18 17:50:07 +030071 errno = 0;
Hu Tao659268f2014-06-10 19:15:27 +080072 end = strtoll(str, &endptr, 0);
Michael S. Tsirkinc210ee92014-06-18 17:50:07 +030073 if (errno == 0 && endptr > str && start <= end &&
Hu Tao659268f2014-06-10 19:15:27 +080074 (start > INT64_MAX - 65536 ||
75 end < start + 65536)) {
76 if (*endptr == '\0') {
77 cur = g_malloc0(sizeof(*cur));
78 cur->begin = start;
79 cur->end = end + 1;
80 siv->ranges =
81 g_list_insert_sorted_merged(siv->ranges,
82 cur,
83 range_compare);
84 cur = NULL;
85 str = NULL;
86 } else if (*endptr == ',') {
87 str = endptr + 1;
88 cur = g_malloc0(sizeof(*cur));
89 cur->begin = start;
90 cur->end = end + 1;
91 siv->ranges =
92 g_list_insert_sorted_merged(siv->ranges,
93 cur,
94 range_compare);
95 cur = NULL;
96 } else {
97 goto error;
98 }
99 } else {
100 goto error;
101 }
102 } else if (*endptr == ',') {
103 str = endptr + 1;
104 cur = g_malloc0(sizeof(*cur));
105 cur->begin = start;
106 cur->end = start + 1;
107 siv->ranges = g_list_insert_sorted_merged(siv->ranges,
108 cur,
109 range_compare);
110 cur = NULL;
111 } else {
112 goto error;
113 }
114 } else {
115 goto error;
116 }
117 } while (str);
118
119 return;
120error:
Michael S. Tsirkin0d156682014-06-16 18:07:03 +0300121 g_list_foreach(siv->ranges, free_range, NULL);
122 g_list_free(siv->ranges);
123 siv->ranges = NULL;
Hu Tao659268f2014-06-10 19:15:27 +0800124}
125
126static void
127start_list(Visitor *v, const char *name, Error **errp)
128{
Eric Blaked7bea752016-01-29 06:48:38 -0700129 StringInputVisitor *siv = to_siv(v);
Hu Tao659268f2014-06-10 19:15:27 +0800130
131 parse_str(siv, errp);
132
133 siv->cur_range = g_list_first(siv->ranges);
134 if (siv->cur_range) {
135 Range *r = siv->cur_range->data;
136 if (r) {
137 siv->cur = r->begin;
138 }
139 }
140}
141
Eric Blakee65d89b2016-02-17 23:48:23 -0700142static GenericList *next_list(Visitor *v, GenericList **list, size_t size)
Hu Tao659268f2014-06-10 19:15:27 +0800143{
Eric Blaked7bea752016-01-29 06:48:38 -0700144 StringInputVisitor *siv = to_siv(v);
Hu Tao659268f2014-06-10 19:15:27 +0800145 GenericList **link;
146 Range *r;
147
148 if (!siv->ranges || !siv->cur_range) {
149 return NULL;
150 }
151
152 r = siv->cur_range->data;
153 if (!r) {
154 return NULL;
155 }
156
157 if (siv->cur < r->begin || siv->cur >= r->end) {
158 siv->cur_range = g_list_next(siv->cur_range);
159 if (!siv->cur_range) {
160 return NULL;
161 }
162 r = siv->cur_range->data;
163 if (!r) {
164 return NULL;
165 }
166 siv->cur = r->begin;
167 }
168
169 if (siv->head) {
170 link = list;
171 siv->head = false;
172 } else {
173 link = &(*list)->next;
174 }
175
Eric Blakee65d89b2016-02-17 23:48:23 -0700176 *link = g_malloc0(size);
Hu Tao659268f2014-06-10 19:15:27 +0800177 return *link;
178}
179
Eric Blake08f95412016-01-29 06:48:59 -0700180static void end_list(Visitor *v)
Hu Tao659268f2014-06-10 19:15:27 +0800181{
Eric Blaked7bea752016-01-29 06:48:38 -0700182 StringInputVisitor *siv = to_siv(v);
Hu Tao659268f2014-06-10 19:15:27 +0800183 siv->head = true;
184}
185
Eric Blake0b2a0d62016-01-29 06:48:56 -0700186static void parse_type_int64(Visitor *v, const char *name, int64_t *obj,
Eric Blake4c403142016-01-29 06:48:49 -0700187 Error **errp)
Paolo Bonzinia020f982012-02-09 09:36:37 +0100188{
Eric Blaked7bea752016-01-29 06:48:38 -0700189 StringInputVisitor *siv = to_siv(v);
Paolo Bonzinia020f982012-02-09 09:36:37 +0100190
Hu Tao659268f2014-06-10 19:15:27 +0800191 if (!siv->string) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100192 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
193 "integer");
Paolo Bonzinia020f982012-02-09 09:36:37 +0100194 return;
195 }
196
Hu Tao659268f2014-06-10 19:15:27 +0800197 parse_str(siv, errp);
198
199 if (!siv->ranges) {
200 goto error;
201 }
202
203 if (!siv->cur_range) {
204 Range *r;
205
206 siv->cur_range = g_list_first(siv->ranges);
207 if (!siv->cur_range) {
208 goto error;
209 }
210
211 r = siv->cur_range->data;
212 if (!r) {
213 goto error;
214 }
215
216 siv->cur = r->begin;
217 }
218
219 *obj = siv->cur;
220 siv->cur++;
221 return;
222
223error:
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100224 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name,
225 "an int64 value or range");
Paolo Bonzinia020f982012-02-09 09:36:37 +0100226}
227
Eric Blake0b2a0d62016-01-29 06:48:56 -0700228static void parse_type_uint64(Visitor *v, const char *name, uint64_t *obj,
Eric Blakef755dea2016-01-29 06:48:50 -0700229 Error **errp)
230{
231 /* FIXME: parse_type_int64 mishandles values over INT64_MAX */
232 int64_t i;
233 Error *err = NULL;
Eric Blake0b2a0d62016-01-29 06:48:56 -0700234 parse_type_int64(v, name, &i, &err);
Eric Blakef755dea2016-01-29 06:48:50 -0700235 if (err) {
236 error_propagate(errp, err);
237 } else {
238 *obj = i;
239 }
240}
241
Eric Blake0b2a0d62016-01-29 06:48:56 -0700242static void parse_type_size(Visitor *v, const char *name, uint64_t *obj,
Paolo Bonzinia5829cc2014-02-08 11:01:44 +0100243 Error **errp)
244{
Eric Blaked7bea752016-01-29 06:48:38 -0700245 StringInputVisitor *siv = to_siv(v);
Paolo Bonzinia5829cc2014-02-08 11:01:44 +0100246 Error *err = NULL;
247 uint64_t val;
248
249 if (siv->string) {
250 parse_option_size(name, siv->string, &val, &err);
251 } else {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100252 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
253 "size");
Paolo Bonzinia5829cc2014-02-08 11:01:44 +0100254 return;
255 }
256 if (err) {
257 error_propagate(errp, err);
258 return;
259 }
260
261 *obj = val;
262}
263
Eric Blake0b2a0d62016-01-29 06:48:56 -0700264static void parse_type_bool(Visitor *v, const char *name, bool *obj,
Paolo Bonzinia020f982012-02-09 09:36:37 +0100265 Error **errp)
266{
Eric Blaked7bea752016-01-29 06:48:38 -0700267 StringInputVisitor *siv = to_siv(v);
Paolo Bonzinia020f982012-02-09 09:36:37 +0100268
269 if (siv->string) {
270 if (!strcasecmp(siv->string, "on") ||
271 !strcasecmp(siv->string, "yes") ||
272 !strcasecmp(siv->string, "true")) {
273 *obj = true;
274 return;
275 }
276 if (!strcasecmp(siv->string, "off") ||
277 !strcasecmp(siv->string, "no") ||
278 !strcasecmp(siv->string, "false")) {
279 *obj = false;
280 return;
281 }
282 }
283
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100284 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
285 "boolean");
Paolo Bonzinia020f982012-02-09 09:36:37 +0100286}
287
Eric Blake0b2a0d62016-01-29 06:48:56 -0700288static void parse_type_str(Visitor *v, const char *name, char **obj,
Paolo Bonzinia020f982012-02-09 09:36:37 +0100289 Error **errp)
290{
Eric Blaked7bea752016-01-29 06:48:38 -0700291 StringInputVisitor *siv = to_siv(v);
Paolo Bonzinia020f982012-02-09 09:36:37 +0100292 if (siv->string) {
293 *obj = g_strdup(siv->string);
294 } else {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100295 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
296 "string");
Paolo Bonzinia020f982012-02-09 09:36:37 +0100297 }
298}
299
Eric Blake0b2a0d62016-01-29 06:48:56 -0700300static void parse_type_number(Visitor *v, const char *name, double *obj,
Paolo Bonzinia020f982012-02-09 09:36:37 +0100301 Error **errp)
302{
Eric Blaked7bea752016-01-29 06:48:38 -0700303 StringInputVisitor *siv = to_siv(v);
Paolo Bonzinia020f982012-02-09 09:36:37 +0100304 char *endp = (char *) siv->string;
305 double val;
306
307 errno = 0;
308 if (siv->string) {
309 val = strtod(siv->string, &endp);
310 }
311 if (!siv->string || errno || endp == siv->string || *endp) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100312 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
313 "number");
Paolo Bonzinia020f982012-02-09 09:36:37 +0100314 return;
315 }
316
317 *obj = val;
318}
319
Eric Blake0b2a0d62016-01-29 06:48:56 -0700320static void parse_optional(Visitor *v, const char *name, bool *present)
Paolo Bonzinia020f982012-02-09 09:36:37 +0100321{
Eric Blaked7bea752016-01-29 06:48:38 -0700322 StringInputVisitor *siv = to_siv(v);
Paolo Bonzinia020f982012-02-09 09:36:37 +0100323
324 if (!siv->string) {
325 *present = false;
326 return;
327 }
328
329 *present = true;
330}
331
332Visitor *string_input_get_visitor(StringInputVisitor *v)
333{
334 return &v->visitor;
335}
336
337void string_input_visitor_cleanup(StringInputVisitor *v)
338{
Michael S. Tsirkin0d156682014-06-16 18:07:03 +0300339 g_list_foreach(v->ranges, free_range, NULL);
340 g_list_free(v->ranges);
Paolo Bonzinia020f982012-02-09 09:36:37 +0100341 g_free(v);
342}
343
344StringInputVisitor *string_input_visitor_new(const char *str)
345{
346 StringInputVisitor *v;
347
348 v = g_malloc0(sizeof(*v));
349
350 v->visitor.type_enum = input_type_enum;
Eric Blake4c403142016-01-29 06:48:49 -0700351 v->visitor.type_int64 = parse_type_int64;
Eric Blakef755dea2016-01-29 06:48:50 -0700352 v->visitor.type_uint64 = parse_type_uint64;
Paolo Bonzinia5829cc2014-02-08 11:01:44 +0100353 v->visitor.type_size = parse_type_size;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100354 v->visitor.type_bool = parse_type_bool;
355 v->visitor.type_str = parse_type_str;
356 v->visitor.type_number = parse_type_number;
Hu Tao659268f2014-06-10 19:15:27 +0800357 v->visitor.start_list = start_list;
358 v->visitor.next_list = next_list;
359 v->visitor.end_list = end_list;
Markus Armbrustere2cd0f42014-05-07 09:53:46 +0200360 v->visitor.optional = parse_optional;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100361
362 v->string = str;
Hu Tao659268f2014-06-10 19:15:27 +0800363 v->head = true;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100364 return v;
365}