blob: 5115536b153903dc1abae78ca70d76a1f69e1194 [file] [log] [blame]
Paolo Bonzinia020f982012-02-09 09:36:37 +01001/*
2 * String printing 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"
Philippe Mathieu-Daudé31e40412019-09-03 14:05:55 +020014#include "qemu/cutils.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010015#include "qapi/string-output-visitor.h"
16#include "qapi/visitor-impl.h"
Paolo Bonzinie41b5092014-02-08 11:01:57 +010017#include <math.h>
Hu Tao69e25562014-06-10 19:15:28 +080018#include "qemu/range.h"
19
20enum ListMode {
21 LM_NONE, /* not traversing a list of repeated options */
Eric Blaked9f62dd2016-04-28 15:45:31 -060022 LM_STARTED, /* next_list() ready to be called */
Hu Tao69e25562014-06-10 19:15:28 +080023
24 LM_IN_PROGRESS, /* next_list() has been called.
25 *
26 * Generating the next list link will consume the most
27 * recently parsed QemuOpt instance of the repeated
28 * option.
29 *
30 * Parsing a value into the list link will examine the
31 * next QemuOpt instance of the repeated option, and
32 * possibly enter LM_SIGNED_INTERVAL or
33 * LM_UNSIGNED_INTERVAL.
34 */
35
36 LM_SIGNED_INTERVAL, /* next_list() has been called.
37 *
38 * Generating the next list link will consume the most
39 * recently stored element from the signed interval,
40 * parsed from the most recent QemuOpt instance of the
41 * repeated option. This may consume QemuOpt itself
42 * and return to LM_IN_PROGRESS.
43 *
44 * Parsing a value into the list link will store the
45 * next element of the signed interval.
46 */
47
48 LM_UNSIGNED_INTERVAL,/* Same as above, only for an unsigned interval. */
49
Eric Blaked9f62dd2016-04-28 15:45:31 -060050 LM_END, /* next_list() called, about to see last element. */
Hu Tao69e25562014-06-10 19:15:28 +080051};
52
53typedef enum ListMode ListMode;
Paolo Bonzinia020f982012-02-09 09:36:37 +010054
55struct StringOutputVisitor
56{
57 Visitor visitor;
Paolo Bonzini0b7593e2014-02-08 11:01:50 +010058 bool human;
Hu Tao69e25562014-06-10 19:15:28 +080059 GString *string;
Eric Blake3b098d52016-06-09 10:48:43 -060060 char **result;
Hu Tao69e25562014-06-10 19:15:28 +080061 ListMode list_mode;
62 union {
63 int64_t s;
64 uint64_t u;
65 } range_start, range_end;
66 GList *ranges;
Eric Blake1158bb22016-06-09 10:48:34 -060067 void *list; /* Only needed for sanity checking the caller */
Kevin Wolf014b99a2024-01-09 19:17:17 +010068 unsigned int struct_nesting;
Paolo Bonzinia020f982012-02-09 09:36:37 +010069};
70
Eric Blaked7bea752016-01-29 06:48:38 -070071static StringOutputVisitor *to_sov(Visitor *v)
72{
73 return container_of(v, StringOutputVisitor, visitor);
74}
75
Paolo Bonzinia020f982012-02-09 09:36:37 +010076static void string_output_set(StringOutputVisitor *sov, char *string)
77{
Kevin Wolfea7ec152023-11-21 18:34:16 +010078 switch (sov->list_mode) {
79 case LM_STARTED:
80 sov->list_mode = LM_IN_PROGRESS;
81 /* fall through */
82 case LM_NONE:
83 if (sov->string) {
84 g_string_free(sov->string, true);
85 }
86 sov->string = g_string_new(string);
87 g_free(string);
88 break;
89
90 case LM_IN_PROGRESS:
91 case LM_END:
92 g_string_append(sov->string, ", ");
93 g_string_append(sov->string, string);
94 break;
95
96 default:
97 abort();
Hu Tao69e25562014-06-10 19:15:28 +080098 }
Hu Tao69e25562014-06-10 19:15:28 +080099}
100
101static void string_output_append(StringOutputVisitor *sov, int64_t a)
102{
103 Range *r = g_malloc0(sizeof(*r));
Markus Armbrustera0efbf12016-07-01 13:47:47 +0200104
105 range_set_bounds(r, a, a);
Eric Blake7c479592016-05-31 10:41:29 -0600106 sov->ranges = range_list_insert(sov->ranges, r);
Hu Tao69e25562014-06-10 19:15:28 +0800107}
108
109static void string_output_append_range(StringOutputVisitor *sov,
110 int64_t s, int64_t e)
111{
112 Range *r = g_malloc0(sizeof(*r));
Markus Armbrustera0efbf12016-07-01 13:47:47 +0200113
114 range_set_bounds(r, s, e);
Eric Blake7c479592016-05-31 10:41:29 -0600115 sov->ranges = range_list_insert(sov->ranges, r);
Hu Tao69e25562014-06-10 19:15:28 +0800116}
117
118static void format_string(StringOutputVisitor *sov, Range *r, bool next,
119 bool human)
120{
Markus Armbrustera0efbf12016-07-01 13:47:47 +0200121 if (range_lob(r) != range_upb(r)) {
Hu Tao69e25562014-06-10 19:15:28 +0800122 if (human) {
Hu Tao684531a2014-06-20 13:55:42 +0800123 g_string_append_printf(sov->string, "0x%" PRIx64 "-0x%" PRIx64,
Markus Armbrustera0efbf12016-07-01 13:47:47 +0200124 range_lob(r), range_upb(r));
Hu Tao69e25562014-06-10 19:15:28 +0800125
126 } else {
127 g_string_append_printf(sov->string, "%" PRId64 "-%" PRId64,
Markus Armbrustera0efbf12016-07-01 13:47:47 +0200128 range_lob(r), range_upb(r));
Hu Tao69e25562014-06-10 19:15:28 +0800129 }
130 } else {
131 if (human) {
Markus Armbrustera0efbf12016-07-01 13:47:47 +0200132 g_string_append_printf(sov->string, "0x%" PRIx64, range_lob(r));
Hu Tao69e25562014-06-10 19:15:28 +0800133 } else {
Markus Armbrustera0efbf12016-07-01 13:47:47 +0200134 g_string_append_printf(sov->string, "%" PRId64, range_lob(r));
Hu Tao69e25562014-06-10 19:15:28 +0800135 }
136 }
137 if (next) {
138 g_string_append(sov->string, ",");
139 }
Paolo Bonzinia020f982012-02-09 09:36:37 +0100140}
141
Markus Armbruster012d4c92020-07-07 18:05:45 +0200142static bool print_type_int64(Visitor *v, const char *name, int64_t *obj,
Eric Blake4c403142016-01-29 06:48:49 -0700143 Error **errp)
Paolo Bonzinia020f982012-02-09 09:36:37 +0100144{
Eric Blaked7bea752016-01-29 06:48:38 -0700145 StringOutputVisitor *sov = to_sov(v);
Hu Tao69e25562014-06-10 19:15:28 +0800146 GList *l;
147
Kevin Wolf014b99a2024-01-09 19:17:17 +0100148 if (sov->struct_nesting) {
149 return true;
150 }
151
Hu Tao69e25562014-06-10 19:15:28 +0800152 switch (sov->list_mode) {
153 case LM_NONE:
154 string_output_append(sov, *obj);
155 break;
156
157 case LM_STARTED:
158 sov->range_start.s = *obj;
159 sov->range_end.s = *obj;
160 sov->list_mode = LM_IN_PROGRESS;
Markus Armbruster012d4c92020-07-07 18:05:45 +0200161 return true;
Hu Tao69e25562014-06-10 19:15:28 +0800162
163 case LM_IN_PROGRESS:
164 if (sov->range_end.s + 1 == *obj) {
165 sov->range_end.s++;
166 } else {
167 if (sov->range_start.s == sov->range_end.s) {
168 string_output_append(sov, sov->range_end.s);
169 } else {
170 assert(sov->range_start.s < sov->range_end.s);
171 string_output_append_range(sov, sov->range_start.s,
172 sov->range_end.s);
173 }
174
175 sov->range_start.s = *obj;
176 sov->range_end.s = *obj;
177 }
Markus Armbruster012d4c92020-07-07 18:05:45 +0200178 return true;
Hu Tao69e25562014-06-10 19:15:28 +0800179
180 case LM_END:
181 if (sov->range_end.s + 1 == *obj) {
182 sov->range_end.s++;
183 assert(sov->range_start.s < sov->range_end.s);
184 string_output_append_range(sov, sov->range_start.s,
185 sov->range_end.s);
186 } else {
187 if (sov->range_start.s == sov->range_end.s) {
188 string_output_append(sov, sov->range_end.s);
189 } else {
190 assert(sov->range_start.s < sov->range_end.s);
191
192 string_output_append_range(sov, sov->range_start.s,
193 sov->range_end.s);
194 }
195 string_output_append(sov, *obj);
196 }
197 break;
198
199 default:
200 abort();
201 }
202
203 l = sov->ranges;
204 while (l) {
205 Range *r = l->data;
206 format_string(sov, r, l->next != NULL, false);
207 l = l->next;
208 }
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100209
210 if (sov->human) {
Hu Tao69e25562014-06-10 19:15:28 +0800211 l = sov->ranges;
212 g_string_append(sov->string, " (");
213 while (l) {
214 Range *r = l->data;
Michael S. Tsirkin56fdfb62014-06-18 17:59:51 +0300215 format_string(sov, r, l->next != NULL, true);
Hu Tao69e25562014-06-10 19:15:28 +0800216 l = l->next;
217 }
218 g_string_append(sov->string, ")");
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100219 }
Markus Armbruster012d4c92020-07-07 18:05:45 +0200220
221 return true;
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100222}
223
Markus Armbruster012d4c92020-07-07 18:05:45 +0200224static bool print_type_uint64(Visitor *v, const char *name, uint64_t *obj,
Eric Blakef755dea2016-01-29 06:48:50 -0700225 Error **errp)
226{
227 /* FIXME: print_type_int64 mishandles values over INT64_MAX */
228 int64_t i = *obj;
Markus Armbruster012d4c92020-07-07 18:05:45 +0200229 return print_type_int64(v, name, &i, errp);
Eric Blakef755dea2016-01-29 06:48:50 -0700230}
231
Markus Armbruster012d4c92020-07-07 18:05:45 +0200232static bool print_type_size(Visitor *v, const char *name, uint64_t *obj,
Eric Blake0b2a0d62016-01-29 06:48:56 -0700233 Error **errp)
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100234{
Eric Blaked7bea752016-01-29 06:48:38 -0700235 StringOutputVisitor *sov = to_sov(v);
Peter Xu22951aa2017-05-12 12:17:40 +0800236 uint64_t val;
237 char *out, *psize;
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100238
Kevin Wolf014b99a2024-01-09 19:17:17 +0100239 if (sov->struct_nesting) {
240 return true;
241 }
242
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100243 if (!sov->human) {
Paolo Bonzinie41b5092014-02-08 11:01:57 +0100244 out = g_strdup_printf("%"PRIu64, *obj);
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100245 string_output_set(sov, out);
Markus Armbruster012d4c92020-07-07 18:05:45 +0200246 return true;
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100247 }
248
249 val = *obj;
Peter Xu22951aa2017-05-12 12:17:40 +0800250 psize = size_to_str(val);
251 out = g_strdup_printf("%"PRIu64" (%s)", val, psize);
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100252 string_output_set(sov, out);
Peter Xu22951aa2017-05-12 12:17:40 +0800253
254 g_free(psize);
Markus Armbruster012d4c92020-07-07 18:05:45 +0200255 return true;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100256}
257
Markus Armbruster012d4c92020-07-07 18:05:45 +0200258static bool print_type_bool(Visitor *v, const char *name, bool *obj,
Paolo Bonzinia020f982012-02-09 09:36:37 +0100259 Error **errp)
260{
Eric Blaked7bea752016-01-29 06:48:38 -0700261 StringOutputVisitor *sov = to_sov(v);
Kevin Wolf014b99a2024-01-09 19:17:17 +0100262
263 if (sov->struct_nesting) {
264 return true;
265 }
266
Paolo Bonzinia020f982012-02-09 09:36:37 +0100267 string_output_set(sov, g_strdup(*obj ? "true" : "false"));
Markus Armbruster012d4c92020-07-07 18:05:45 +0200268 return true;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100269}
270
Markus Armbruster012d4c92020-07-07 18:05:45 +0200271static bool print_type_str(Visitor *v, const char *name, char **obj,
Paolo Bonzinia020f982012-02-09 09:36:37 +0100272 Error **errp)
273{
Eric Blaked7bea752016-01-29 06:48:38 -0700274 StringOutputVisitor *sov = to_sov(v);
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100275 char *out;
276
Kevin Wolf014b99a2024-01-09 19:17:17 +0100277 if (sov->struct_nesting) {
278 return true;
279 }
280
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100281 if (sov->human) {
282 out = *obj ? g_strdup_printf("\"%s\"", *obj) : g_strdup("<null>");
283 } else {
284 out = g_strdup(*obj ? *obj : "");
285 }
286 string_output_set(sov, out);
Markus Armbruster012d4c92020-07-07 18:05:45 +0200287 return true;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100288}
289
Markus Armbruster012d4c92020-07-07 18:05:45 +0200290static bool print_type_number(Visitor *v, const char *name, double *obj,
Paolo Bonzinia020f982012-02-09 09:36:37 +0100291 Error **errp)
292{
Eric Blaked7bea752016-01-29 06:48:38 -0700293 StringOutputVisitor *sov = to_sov(v);
Kevin Wolf014b99a2024-01-09 19:17:17 +0100294
295 if (sov->struct_nesting) {
296 return true;
297 }
298
Markus Armbruster54addb02020-12-10 17:14:50 +0100299 string_output_set(sov, g_strdup_printf("%.17g", *obj));
Markus Armbruster012d4c92020-07-07 18:05:45 +0200300 return true;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100301}
302
Markus Armbruster012d4c92020-07-07 18:05:45 +0200303static bool print_type_null(Visitor *v, const char *name, QNull **obj,
Markus Armbrusterd2f95f42017-06-26 18:22:59 +0200304 Error **errp)
Greg Kurza7333712016-12-16 16:26:09 +0100305{
306 StringOutputVisitor *sov = to_sov(v);
307 char *out;
308
Kevin Wolf014b99a2024-01-09 19:17:17 +0100309 if (sov->struct_nesting) {
310 return true;
311 }
312
Greg Kurza7333712016-12-16 16:26:09 +0100313 if (sov->human) {
314 out = g_strdup("<null>");
315 } else {
316 out = g_strdup("");
317 }
318 string_output_set(sov, out);
Markus Armbruster012d4c92020-07-07 18:05:45 +0200319 return true;
Greg Kurza7333712016-12-16 16:26:09 +0100320}
321
Stefan Hajnocziff32bb52023-12-12 08:49:34 -0500322static bool start_struct(Visitor *v, const char *name, void **obj,
323 size_t size, Error **errp)
324{
Kevin Wolf014b99a2024-01-09 19:17:17 +0100325 StringOutputVisitor *sov = to_sov(v);
326
327 sov->struct_nesting++;
Stefan Hajnocziff32bb52023-12-12 08:49:34 -0500328 return true;
329}
330
331static void end_struct(Visitor *v, void **obj)
332{
333 StringOutputVisitor *sov = to_sov(v);
334
Kevin Wolf014b99a2024-01-09 19:17:17 +0100335 if (--sov->struct_nesting) {
336 return;
337 }
338
Stefan Hajnocziff32bb52023-12-12 08:49:34 -0500339 /* TODO actually print struct fields */
340 string_output_set(sov, g_strdup("<omitted>"));
341}
342
Markus Armbruster012d4c92020-07-07 18:05:45 +0200343static bool
Eric Blaked9f62dd2016-04-28 15:45:31 -0600344start_list(Visitor *v, const char *name, GenericList **list, size_t size,
345 Error **errp)
Hu Tao69e25562014-06-10 19:15:28 +0800346{
Eric Blaked7bea752016-01-29 06:48:38 -0700347 StringOutputVisitor *sov = to_sov(v);
Hu Tao69e25562014-06-10 19:15:28 +0800348
Kevin Wolf014b99a2024-01-09 19:17:17 +0100349 if (sov->struct_nesting) {
350 return true;
351 }
352
Hu Tao69e25562014-06-10 19:15:28 +0800353 /* we can't traverse a list in a list */
354 assert(sov->list_mode == LM_NONE);
Eric Blaked9f62dd2016-04-28 15:45:31 -0600355 /* We don't support visits without a list */
356 assert(list);
Eric Blake1158bb22016-06-09 10:48:34 -0600357 sov->list = list;
Eric Blaked9f62dd2016-04-28 15:45:31 -0600358 /* List handling is only needed if there are at least two elements */
359 if (*list && (*list)->next) {
360 sov->list_mode = LM_STARTED;
361 }
Markus Armbruster012d4c92020-07-07 18:05:45 +0200362 return true;
Hu Tao69e25562014-06-10 19:15:28 +0800363}
364
Eric Blaked9f62dd2016-04-28 15:45:31 -0600365static GenericList *next_list(Visitor *v, GenericList *tail, size_t size)
Hu Tao69e25562014-06-10 19:15:28 +0800366{
Eric Blaked7bea752016-01-29 06:48:38 -0700367 StringOutputVisitor *sov = to_sov(v);
Eric Blaked9f62dd2016-04-28 15:45:31 -0600368 GenericList *ret = tail->next;
Hu Tao69e25562014-06-10 19:15:28 +0800369
Kevin Wolf014b99a2024-01-09 19:17:17 +0100370 if (sov->struct_nesting) {
371 return ret;
372 }
373
Eric Blaked9f62dd2016-04-28 15:45:31 -0600374 if (ret && !ret->next) {
375 sov->list_mode = LM_END;
Hu Tao69e25562014-06-10 19:15:28 +0800376 }
Hu Tao69e25562014-06-10 19:15:28 +0800377 return ret;
378}
379
Eric Blake1158bb22016-06-09 10:48:34 -0600380static void end_list(Visitor *v, void **obj)
Hu Tao69e25562014-06-10 19:15:28 +0800381{
Eric Blaked7bea752016-01-29 06:48:38 -0700382 StringOutputVisitor *sov = to_sov(v);
Hu Tao69e25562014-06-10 19:15:28 +0800383
Kevin Wolf014b99a2024-01-09 19:17:17 +0100384 if (sov->struct_nesting) {
385 return;
386 }
387
Eric Blake1158bb22016-06-09 10:48:34 -0600388 assert(sov->list == obj);
Hu Tao69e25562014-06-10 19:15:28 +0800389 assert(sov->list_mode == LM_STARTED ||
390 sov->list_mode == LM_END ||
391 sov->list_mode == LM_NONE ||
392 sov->list_mode == LM_IN_PROGRESS);
393 sov->list_mode = LM_NONE;
Hu Tao69e25562014-06-10 19:15:28 +0800394}
395
Eric Blake3b098d52016-06-09 10:48:43 -0600396static void string_output_complete(Visitor *v, void *opaque)
Paolo Bonzinia020f982012-02-09 09:36:37 +0100397{
Eric Blake3b098d52016-06-09 10:48:43 -0600398 StringOutputVisitor *sov = to_sov(v);
Paolo Bonzinia020f982012-02-09 09:36:37 +0100399
Eric Blake3b098d52016-06-09 10:48:43 -0600400 assert(opaque == sov->result);
401 *sov->result = g_string_free(sov->string, false);
402 sov->string = NULL;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100403}
404
Michael S. Tsirkin0d156682014-06-16 18:07:03 +0300405static void free_range(void *range, void *dummy)
406{
407 g_free(range);
408}
409
Eric Blake2c0ef9f2016-06-09 10:48:35 -0600410static void string_output_free(Visitor *v)
411{
412 StringOutputVisitor *sov = to_sov(v);
413
Hu Tao69e25562014-06-10 19:15:28 +0800414 if (sov->string) {
415 g_string_free(sov->string, true);
416 }
417
Michael S. Tsirkin0d156682014-06-16 18:07:03 +0300418 g_list_foreach(sov->ranges, free_range, NULL);
419 g_list_free(sov->ranges);
Paolo Bonzinia020f982012-02-09 09:36:37 +0100420 g_free(sov);
421}
422
Eric Blake3b098d52016-06-09 10:48:43 -0600423Visitor *string_output_visitor_new(bool human, char **result)
Paolo Bonzinia020f982012-02-09 09:36:37 +0100424{
425 StringOutputVisitor *v;
426
427 v = g_malloc0(sizeof(*v));
428
Hu Tao69e25562014-06-10 19:15:28 +0800429 v->string = g_string_new(NULL);
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100430 v->human = human;
Eric Blake3b098d52016-06-09 10:48:43 -0600431 v->result = result;
432 *result = NULL;
433
Eric Blake983f52d2016-04-28 15:45:09 -0600434 v->visitor.type = VISITOR_OUTPUT;
Eric Blake4c403142016-01-29 06:48:49 -0700435 v->visitor.type_int64 = print_type_int64;
Eric Blakef755dea2016-01-29 06:48:50 -0700436 v->visitor.type_uint64 = print_type_uint64;
Paolo Bonzini0b7593e2014-02-08 11:01:50 +0100437 v->visitor.type_size = print_type_size;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100438 v->visitor.type_bool = print_type_bool;
439 v->visitor.type_str = print_type_str;
440 v->visitor.type_number = print_type_number;
Greg Kurza7333712016-12-16 16:26:09 +0100441 v->visitor.type_null = print_type_null;
Stefan Hajnocziff32bb52023-12-12 08:49:34 -0500442 v->visitor.start_struct = start_struct;
443 v->visitor.end_struct = end_struct;
Hu Tao69e25562014-06-10 19:15:28 +0800444 v->visitor.start_list = start_list;
445 v->visitor.next_list = next_list;
446 v->visitor.end_list = end_list;
Eric Blake3b098d52016-06-09 10:48:43 -0600447 v->visitor.complete = string_output_complete;
Eric Blake2c0ef9f2016-06-09 10:48:35 -0600448 v->visitor.free = string_output_free;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100449
Eric Blake3b098d52016-06-09 10:48:43 -0600450 return &v->visitor;
Paolo Bonzinia020f982012-02-09 09:36:37 +0100451}