virtio-scsi: suppress virtqueue kick during processing
[qemu.git] / qobject / qjson.c
1 /*
2 * QObject JSON integration
3 *
4 * Copyright IBM, Corp. 2009
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
10 * See the COPYING.LIB file in the top-level directory.
11 *
12 */
13
14 #include "qemu/osdep.h"
15 #include "qapi/qmp/json-lexer.h"
16 #include "qapi/qmp/json-parser.h"
17 #include "qapi/qmp/json-streamer.h"
18 #include "qapi/qmp/qjson.h"
19 #include "qapi/qmp/types.h"
20 #include "qemu/unicode.h"
21
22 typedef struct JSONParsingState
23 {
24 JSONMessageParser parser;
25 va_list *ap;
26 QObject *result;
27 } JSONParsingState;
28
29 static void parse_json(JSONMessageParser *parser, GQueue *tokens)
30 {
31 JSONParsingState *s = container_of(parser, JSONParsingState, parser);
32 s->result = json_parser_parse(tokens, s->ap);
33 }
34
35 QObject *qobject_from_jsonv(const char *string, va_list *ap)
36 {
37 JSONParsingState state = {};
38
39 state.ap = ap;
40
41 json_message_parser_init(&state.parser, parse_json);
42 json_message_parser_feed(&state.parser, string, strlen(string));
43 json_message_parser_flush(&state.parser);
44 json_message_parser_destroy(&state.parser);
45
46 return state.result;
47 }
48
49 QObject *qobject_from_json(const char *string)
50 {
51 return qobject_from_jsonv(string, NULL);
52 }
53
54 /*
55 * IMPORTANT: This function aborts on error, thus it must not
56 * be used with untrusted arguments.
57 */
58 QObject *qobject_from_jsonf(const char *string, ...)
59 {
60 QObject *obj;
61 va_list ap;
62
63 va_start(ap, string);
64 obj = qobject_from_jsonv(string, &ap);
65 va_end(ap);
66
67 assert(obj != NULL);
68 return obj;
69 }
70
71 typedef struct ToJsonIterState
72 {
73 int indent;
74 int pretty;
75 int count;
76 QString *str;
77 } ToJsonIterState;
78
79 static void to_json(const QObject *obj, QString *str, int pretty, int indent);
80
81 static void to_json_dict_iter(const char *key, QObject *obj, void *opaque)
82 {
83 ToJsonIterState *s = opaque;
84 QString *qkey;
85 int j;
86
87 if (s->count) {
88 qstring_append(s->str, s->pretty ? "," : ", ");
89 }
90
91 if (s->pretty) {
92 qstring_append(s->str, "\n");
93 for (j = 0 ; j < s->indent ; j++)
94 qstring_append(s->str, " ");
95 }
96
97 qkey = qstring_from_str(key);
98 to_json(QOBJECT(qkey), s->str, s->pretty, s->indent);
99 QDECREF(qkey);
100
101 qstring_append(s->str, ": ");
102 to_json(obj, s->str, s->pretty, s->indent);
103 s->count++;
104 }
105
106 static void to_json_list_iter(QObject *obj, void *opaque)
107 {
108 ToJsonIterState *s = opaque;
109 int j;
110
111 if (s->count) {
112 qstring_append(s->str, s->pretty ? "," : ", ");
113 }
114
115 if (s->pretty) {
116 qstring_append(s->str, "\n");
117 for (j = 0 ; j < s->indent ; j++)
118 qstring_append(s->str, " ");
119 }
120
121 to_json(obj, s->str, s->pretty, s->indent);
122 s->count++;
123 }
124
125 static void to_json(const QObject *obj, QString *str, int pretty, int indent)
126 {
127 switch (qobject_type(obj)) {
128 case QTYPE_QNULL:
129 qstring_append(str, "null");
130 break;
131 case QTYPE_QINT: {
132 QInt *val = qobject_to_qint(obj);
133 char buffer[1024];
134
135 snprintf(buffer, sizeof(buffer), "%" PRId64, qint_get_int(val));
136 qstring_append(str, buffer);
137 break;
138 }
139 case QTYPE_QSTRING: {
140 QString *val = qobject_to_qstring(obj);
141 const char *ptr;
142 int cp;
143 char buf[16];
144 char *end;
145
146 ptr = qstring_get_str(val);
147 qstring_append(str, "\"");
148
149 for (; *ptr; ptr = end) {
150 cp = mod_utf8_codepoint(ptr, 6, &end);
151 switch (cp) {
152 case '\"':
153 qstring_append(str, "\\\"");
154 break;
155 case '\\':
156 qstring_append(str, "\\\\");
157 break;
158 case '\b':
159 qstring_append(str, "\\b");
160 break;
161 case '\f':
162 qstring_append(str, "\\f");
163 break;
164 case '\n':
165 qstring_append(str, "\\n");
166 break;
167 case '\r':
168 qstring_append(str, "\\r");
169 break;
170 case '\t':
171 qstring_append(str, "\\t");
172 break;
173 default:
174 if (cp < 0) {
175 cp = 0xFFFD; /* replacement character */
176 }
177 if (cp > 0xFFFF) {
178 /* beyond BMP; need a surrogate pair */
179 snprintf(buf, sizeof(buf), "\\u%04X\\u%04X",
180 0xD800 + ((cp - 0x10000) >> 10),
181 0xDC00 + ((cp - 0x10000) & 0x3FF));
182 } else if (cp < 0x20 || cp >= 0x7F) {
183 snprintf(buf, sizeof(buf), "\\u%04X", cp);
184 } else {
185 buf[0] = cp;
186 buf[1] = 0;
187 }
188 qstring_append(str, buf);
189 }
190 };
191
192 qstring_append(str, "\"");
193 break;
194 }
195 case QTYPE_QDICT: {
196 ToJsonIterState s;
197 QDict *val = qobject_to_qdict(obj);
198
199 s.count = 0;
200 s.str = str;
201 s.indent = indent + 1;
202 s.pretty = pretty;
203 qstring_append(str, "{");
204 qdict_iter(val, to_json_dict_iter, &s);
205 if (pretty) {
206 int j;
207 qstring_append(str, "\n");
208 for (j = 0 ; j < indent ; j++)
209 qstring_append(str, " ");
210 }
211 qstring_append(str, "}");
212 break;
213 }
214 case QTYPE_QLIST: {
215 ToJsonIterState s;
216 QList *val = qobject_to_qlist(obj);
217
218 s.count = 0;
219 s.str = str;
220 s.indent = indent + 1;
221 s.pretty = pretty;
222 qstring_append(str, "[");
223 qlist_iter(val, (void *)to_json_list_iter, &s);
224 if (pretty) {
225 int j;
226 qstring_append(str, "\n");
227 for (j = 0 ; j < indent ; j++)
228 qstring_append(str, " ");
229 }
230 qstring_append(str, "]");
231 break;
232 }
233 case QTYPE_QFLOAT: {
234 QFloat *val = qobject_to_qfloat(obj);
235 char buffer[1024];
236 int len;
237
238 /* FIXME: snprintf() is locale dependent; but JSON requires
239 * numbers to be formatted as if in the C locale. Dependence
240 * on C locale is a pervasive issue in QEMU. */
241 /* FIXME: This risks printing Inf or NaN, which are not valid
242 * JSON values. */
243 /* FIXME: the default precision of 6 for %f often causes
244 * rounding errors; we should be using DBL_DECIMAL_DIG (17),
245 * and only rounding to a shorter number if the result would
246 * still produce the same floating point value. */
247 len = snprintf(buffer, sizeof(buffer), "%f", qfloat_get_double(val));
248 while (len > 0 && buffer[len - 1] == '0') {
249 len--;
250 }
251
252 if (len && buffer[len - 1] == '.') {
253 buffer[len - 1] = 0;
254 } else {
255 buffer[len] = 0;
256 }
257
258 qstring_append(str, buffer);
259 break;
260 }
261 case QTYPE_QBOOL: {
262 QBool *val = qobject_to_qbool(obj);
263
264 if (qbool_get_bool(val)) {
265 qstring_append(str, "true");
266 } else {
267 qstring_append(str, "false");
268 }
269 break;
270 }
271 default:
272 abort();
273 }
274 }
275
276 QString *qobject_to_json(const QObject *obj)
277 {
278 QString *str = qstring_new();
279
280 to_json(obj, str, 0, 0);
281
282 return str;
283 }
284
285 QString *qobject_to_json_pretty(const QObject *obj)
286 {
287 QString *str = qstring_new();
288
289 to_json(obj, str, 1, 0);
290
291 return str;
292 }