]>
Commit | Line | Data |
---|---|---|
06d64c62 MR |
1 | # |
2 | # QAPI visitor generator | |
3 | # | |
4 | # Copyright IBM, Corp. 2011 | |
5 | # | |
6 | # Authors: | |
7 | # Anthony Liguori <aliguori@us.ibm.com> | |
8 | # Michael Roth <mdroth@linux.vnet.ibm.com> | |
9 | # | |
10 | # This work is licensed under the terms of the GNU GPLv2. | |
11 | # See the COPYING.LIB file in the top-level directory. | |
12 | ||
13 | from ordereddict import OrderedDict | |
14 | from qapi import * | |
15 | import sys | |
16 | import os | |
17 | import getopt | |
18 | import errno | |
19 | ||
50f2bdc7 KW |
20 | def generate_visit_struct_fields(name, field_prefix, fn_prefix, members): |
21 | substructs = [] | |
d131c897 | 22 | ret = '' |
50f2bdc7 KW |
23 | full_name = name if not fn_prefix else "%s_%s" % (name, fn_prefix) |
24 | ||
25 | for argname, argentry, optional, structured in parse_args(members): | |
26 | if structured: | |
27 | if not fn_prefix: | |
28 | nested_fn_prefix = argname | |
29 | else: | |
30 | nested_fn_prefix = "%s_%s" % (fn_prefix, argname) | |
31 | ||
32 | nested_field_prefix = "%s%s." % (field_prefix, argname) | |
33 | ret += generate_visit_struct_fields(name, nested_field_prefix, | |
34 | nested_fn_prefix, argentry) | |
35 | ||
36 | ret += mcgen(''' | |
37 | ||
38 | static void visit_type_%(full_name)s_fields(Visitor *m, %(name)s ** obj, Error **errp) | |
39 | { | |
40 | Error *err = NULL; | |
41 | ''', | |
42 | name=name, full_name=full_name) | |
43 | push_indent() | |
d195325b | 44 | |
06d64c62 MR |
45 | for argname, argentry, optional, structured in parse_args(members): |
46 | if optional: | |
47 | ret += mcgen(''' | |
d195325b PB |
48 | visit_start_optional(m, obj ? &(*obj)->%(c_prefix)shas_%(c_name)s : NULL, "%(name)s", &err); |
49 | if (obj && (*obj)->%(prefix)shas_%(c_name)s) { | |
06d64c62 MR |
50 | ''', |
51 | c_prefix=c_var(field_prefix), prefix=field_prefix, | |
52 | c_name=c_var(argname), name=argname) | |
53 | push_indent() | |
54 | ||
55 | if structured: | |
50f2bdc7 | 56 | ret += generate_visit_struct_body(full_name, argname, argentry) |
06d64c62 MR |
57 | else: |
58 | ret += mcgen(''' | |
d195325b | 59 | visit_type_%(type)s(m, obj ? &(*obj)->%(c_prefix)s%(c_name)s : NULL, "%(name)s", &err); |
06d64c62 MR |
60 | ''', |
61 | c_prefix=c_var(field_prefix), prefix=field_prefix, | |
62 | type=type_name(argentry), c_name=c_var(argname), | |
63 | name=argname) | |
64 | ||
65 | if optional: | |
66 | pop_indent() | |
67 | ret += mcgen(''' | |
68 | } | |
d195325b PB |
69 | visit_end_optional(m, &err); |
70 | ''') | |
71 | ||
50f2bdc7 KW |
72 | pop_indent() |
73 | ret += mcgen(''' | |
74 | ||
75 | error_propagate(errp, err); | |
76 | } | |
77 | ''') | |
d131c897 KW |
78 | return ret |
79 | ||
80 | ||
81 | def generate_visit_struct_body(field_prefix, name, members): | |
82 | ret = mcgen(''' | |
83 | if (!error_is_set(errp)) { | |
84 | ''') | |
85 | push_indent() | |
86 | ||
50f2bdc7 KW |
87 | full_name = name if not field_prefix else "%s_%s" % (field_prefix, name) |
88 | ||
d131c897 | 89 | if len(field_prefix): |
d131c897 KW |
90 | ret += mcgen(''' |
91 | Error **errp = &err; /* from outer scope */ | |
92 | Error *err = NULL; | |
93 | visit_start_struct(m, NULL, "", "%(name)s", 0, &err); | |
94 | ''', | |
95 | name=name) | |
96 | else: | |
97 | ret += mcgen(''' | |
98 | Error *err = NULL; | |
99 | visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), &err); | |
100 | ''', | |
101 | name=name) | |
102 | ||
d195325b | 103 | ret += mcgen(''' |
d131c897 KW |
104 | if (!err) { |
105 | if (!obj || *obj) { | |
50f2bdc7 KW |
106 | visit_type_%(name)s_fields(m, obj, &err); |
107 | error_propagate(errp, err); | |
108 | err = NULL; | |
109 | } | |
110 | ''', | |
111 | name=full_name) | |
d195325b | 112 | |
d195325b PB |
113 | pop_indent() |
114 | ret += mcgen(''' | |
115 | /* Always call end_struct if start_struct succeeded. */ | |
116 | visit_end_struct(m, &err); | |
117 | } | |
118 | error_propagate(errp, err); | |
119 | } | |
06d64c62 MR |
120 | ''') |
121 | return ret | |
122 | ||
14d36307 KW |
123 | def generate_visit_struct(expr): |
124 | ||
125 | name = expr['type'] | |
126 | members = expr['data'] | |
127 | ||
50f2bdc7 KW |
128 | ret = generate_visit_struct_fields(name, "", "", members) |
129 | ||
130 | ret += mcgen(''' | |
06d64c62 MR |
131 | |
132 | void visit_type_%(name)s(Visitor *m, %(name)s ** obj, const char *name, Error **errp) | |
133 | { | |
06d64c62 MR |
134 | ''', |
135 | name=name) | |
d195325b | 136 | |
06d64c62 | 137 | push_indent() |
d195325b | 138 | ret += generate_visit_struct_body("", name, members) |
06d64c62 MR |
139 | pop_indent() |
140 | ||
141 | ret += mcgen(''' | |
06d64c62 MR |
142 | } |
143 | ''') | |
144 | return ret | |
145 | ||
146 | def generate_visit_list(name, members): | |
147 | return mcgen(''' | |
148 | ||
149 | void visit_type_%(name)sList(Visitor *m, %(name)sList ** obj, const char *name, Error **errp) | |
150 | { | |
3a86a0fa | 151 | GenericList *i, **prev = (GenericList **)obj; |
d195325b | 152 | Error *err = NULL; |
06d64c62 | 153 | |
d195325b PB |
154 | if (!error_is_set(errp)) { |
155 | visit_start_list(m, name, &err); | |
156 | if (!err) { | |
157 | for (; (i = visit_next_list(m, prev, &err)) != NULL; prev = &i) { | |
158 | %(name)sList *native_i = (%(name)sList *)i; | |
159 | visit_type_%(name)s(m, &native_i->value, NULL, &err); | |
160 | } | |
161 | error_propagate(errp, err); | |
162 | err = NULL; | |
163 | ||
164 | /* Always call end_list if start_list succeeded. */ | |
165 | visit_end_list(m, &err); | |
166 | } | |
167 | error_propagate(errp, err); | |
06d64c62 | 168 | } |
06d64c62 MR |
169 | } |
170 | ''', | |
171 | name=name) | |
172 | ||
173 | def generate_visit_enum(name, members): | |
174 | return mcgen(''' | |
175 | ||
176 | void visit_type_%(name)s(Visitor *m, %(name)s * obj, const char *name, Error **errp) | |
177 | { | |
178 | visit_type_enum(m, (int *)obj, %(name)s_lookup, "%(name)s", name, errp); | |
179 | } | |
180 | ''', | |
181 | name=name) | |
182 | ||
69dd62df KW |
183 | def generate_visit_anon_union(name, members): |
184 | ret = mcgen(''' | |
185 | ||
186 | void visit_type_%(name)s(Visitor *m, %(name)s ** obj, const char *name, Error **errp) | |
187 | { | |
188 | Error *err = NULL; | |
189 | ||
190 | if (!error_is_set(errp)) { | |
191 | visit_start_implicit_struct(m, (void**) obj, sizeof(%(name)s), &err); | |
192 | visit_get_next_type(m, (int*) &(*obj)->kind, %(name)s_qtypes, name, &err); | |
193 | switch ((*obj)->kind) { | |
194 | ''', | |
195 | name=name) | |
196 | ||
197 | for key in members: | |
198 | assert (members[key] in builtin_types | |
199 | or find_struct(members[key]) | |
200 | or find_union(members[key])), "Invalid anonymous union member" | |
201 | ||
202 | ret += mcgen(''' | |
203 | case %(abbrev)s_KIND_%(enum)s: | |
204 | visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, name, &err); | |
205 | break; | |
206 | ''', | |
207 | abbrev = de_camel_case(name).upper(), | |
208 | enum = c_fun(de_camel_case(key),False).upper(), | |
209 | c_type = type_name(members[key]), | |
210 | c_name = c_fun(key)) | |
211 | ||
212 | ret += mcgen(''' | |
213 | default: | |
214 | abort(); | |
215 | } | |
216 | error_propagate(errp, err); | |
217 | err = NULL; | |
218 | visit_end_implicit_struct(m, &err); | |
219 | } | |
220 | } | |
221 | ''') | |
222 | ||
223 | return ret | |
224 | ||
225 | ||
0aef92b9 KW |
226 | def generate_visit_union(expr): |
227 | ||
228 | name = expr['union'] | |
229 | members = expr['data'] | |
230 | ||
231 | base = expr.get('base') | |
50f2bdc7 | 232 | discriminator = expr.get('discriminator') |
0aef92b9 | 233 | |
69dd62df KW |
234 | if discriminator == {}: |
235 | assert not base | |
236 | return generate_visit_anon_union(name, members) | |
237 | ||
06d64c62 MR |
238 | ret = generate_visit_enum('%sKind' % name, members.keys()) |
239 | ||
50f2bdc7 KW |
240 | if base: |
241 | base_fields = find_struct(base)['data'] | |
242 | if discriminator: | |
243 | base_fields = base_fields.copy() | |
244 | del base_fields[discriminator] | |
245 | ret += generate_visit_struct_fields(name, "", "", base_fields) | |
246 | ||
06d64c62 MR |
247 | ret += mcgen(''' |
248 | ||
249 | void visit_type_%(name)s(Visitor *m, %(name)s ** obj, const char *name, Error **errp) | |
250 | { | |
dc8fb6df PB |
251 | Error *err = NULL; |
252 | ||
d195325b PB |
253 | if (!error_is_set(errp)) { |
254 | visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), &err); | |
255 | if (!err) { | |
227ccf6b | 256 | if (obj && *obj) { |
06d64c62 MR |
257 | ''', |
258 | name=name) | |
259 | ||
0aef92b9 | 260 | |
d195325b PB |
261 | push_indent() |
262 | push_indent() | |
0aef92b9 KW |
263 | push_indent() |
264 | ||
265 | if base: | |
50f2bdc7 KW |
266 | ret += mcgen(''' |
267 | visit_type_%(name)s_fields(m, obj, &err); | |
268 | ''', | |
269 | name=name) | |
0aef92b9 KW |
270 | |
271 | pop_indent() | |
272 | ret += mcgen(''' | |
50f2bdc7 | 273 | visit_type_%(name)sKind(m, &(*obj)->kind, "%(type)s", &err); |
0aef92b9 KW |
274 | if (!err) { |
275 | switch ((*obj)->kind) { | |
276 | ''', | |
50f2bdc7 | 277 | name=name, type="type" if not discriminator else discriminator) |
0aef92b9 | 278 | |
dc8fb6df | 279 | for key in members: |
50f2bdc7 KW |
280 | if not discriminator: |
281 | fmt = 'visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "data", &err);' | |
282 | else: | |
283 | fmt = '''visit_start_implicit_struct(m, (void**) &(*obj)->%(c_name)s, sizeof(%(c_type)s), &err); | |
284 | if (!err) { | |
285 | visit_type_%(c_type)s_fields(m, &(*obj)->%(c_name)s, &err); | |
286 | error_propagate(errp, err); | |
287 | err = NULL; | |
288 | visit_end_implicit_struct(m, &err); | |
289 | }''' | |
290 | ||
dc8fb6df | 291 | ret += mcgen(''' |
d195325b | 292 | case %(abbrev)s_KIND_%(enum)s: |
50f2bdc7 | 293 | ''' + fmt + ''' |
d195325b | 294 | break; |
dc8fb6df PB |
295 | ''', |
296 | abbrev = de_camel_case(name).upper(), | |
eda50a65 | 297 | enum = c_fun(de_camel_case(key),False).upper(), |
c664aef5 | 298 | c_type=type_name(members[key]), |
c9da228b | 299 | c_name=c_fun(key)) |
dc8fb6df PB |
300 | |
301 | ret += mcgen(''' | |
d195325b PB |
302 | default: |
303 | abort(); | |
304 | } | |
305 | } | |
306 | error_propagate(errp, err); | |
307 | err = NULL; | |
308 | } | |
309 | ''') | |
310 | pop_indent() | |
311 | ret += mcgen(''' | |
312 | /* Always call end_struct if start_struct succeeded. */ | |
313 | visit_end_struct(m, &err); | |
dc8fb6df | 314 | } |
d195325b PB |
315 | error_propagate(errp, err); |
316 | } | |
317 | ''') | |
318 | ||
319 | pop_indent(); | |
320 | ret += mcgen(''' | |
dc8fb6df PB |
321 | } |
322 | ''') | |
323 | ||
06d64c62 MR |
324 | return ret |
325 | ||
7c946bc4 MR |
326 | def generate_declaration(name, members, genlist=True, builtin_type=False): |
327 | ret = "" | |
328 | if not builtin_type: | |
329 | ret += mcgen(''' | |
06d64c62 MR |
330 | |
331 | void visit_type_%(name)s(Visitor *m, %(name)s ** obj, const char *name, Error **errp); | |
332 | ''', | |
7c946bc4 | 333 | name=name) |
06d64c62 MR |
334 | |
335 | if genlist: | |
336 | ret += mcgen(''' | |
337 | void visit_type_%(name)sList(Visitor *m, %(name)sList ** obj, const char *name, Error **errp); | |
338 | ''', | |
339 | name=name) | |
340 | ||
341 | return ret | |
342 | ||
b9c4b48d AK |
343 | def generate_enum_declaration(name, members, genlist=True): |
344 | ret = "" | |
345 | if genlist: | |
346 | ret += mcgen(''' | |
347 | void visit_type_%(name)sList(Visitor *m, %(name)sList ** obj, const char *name, Error **errp); | |
348 | ''', | |
349 | name=name) | |
350 | ||
351 | return ret | |
352 | ||
06d64c62 MR |
353 | def generate_decl_enum(name, members, genlist=True): |
354 | return mcgen(''' | |
355 | ||
356 | void visit_type_%(name)s(Visitor *m, %(name)s * obj, const char *name, Error **errp); | |
357 | ''', | |
358 | name=name) | |
359 | ||
360 | try: | |
7c946bc4 MR |
361 | opts, args = getopt.gnu_getopt(sys.argv[1:], "chbp:o:", |
362 | ["source", "header", "builtins", "prefix=", | |
363 | "output-dir="]) | |
06d64c62 MR |
364 | except getopt.GetoptError, err: |
365 | print str(err) | |
366 | sys.exit(1) | |
367 | ||
368 | output_dir = "" | |
369 | prefix = "" | |
370 | c_file = 'qapi-visit.c' | |
371 | h_file = 'qapi-visit.h' | |
372 | ||
8d3bc517 AK |
373 | do_c = False |
374 | do_h = False | |
7c946bc4 | 375 | do_builtins = False |
8d3bc517 | 376 | |
06d64c62 MR |
377 | for o, a in opts: |
378 | if o in ("-p", "--prefix"): | |
379 | prefix = a | |
380 | elif o in ("-o", "--output-dir"): | |
381 | output_dir = a + "/" | |
8d3bc517 | 382 | elif o in ("-c", "--source"): |
8d3bc517 | 383 | do_c = True |
19bf7c87 AK |
384 | elif o in ("-h", "--header"): |
385 | do_h = True | |
7c946bc4 MR |
386 | elif o in ("-b", "--builtins"): |
387 | do_builtins = True | |
8d3bc517 AK |
388 | |
389 | if not do_c and not do_h: | |
390 | do_c = True | |
391 | do_h = True | |
06d64c62 MR |
392 | |
393 | c_file = output_dir + prefix + c_file | |
394 | h_file = output_dir + prefix + h_file | |
395 | ||
396 | try: | |
397 | os.makedirs(output_dir) | |
398 | except os.error, e: | |
399 | if e.errno != errno.EEXIST: | |
400 | raise | |
401 | ||
8d3bc517 | 402 | def maybe_open(really, name, opt): |
8d3bc517 AK |
403 | if really: |
404 | return open(name, opt) | |
19bf7c87 AK |
405 | else: |
406 | import StringIO | |
407 | return StringIO.StringIO() | |
8d3bc517 AK |
408 | |
409 | fdef = maybe_open(do_c, c_file, 'w') | |
410 | fdecl = maybe_open(do_h, h_file, 'w') | |
06d64c62 MR |
411 | |
412 | fdef.write(mcgen(''' | |
413 | /* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */ | |
414 | ||
415 | /* | |
416 | * schema-defined QAPI visitor functions | |
417 | * | |
418 | * Copyright IBM, Corp. 2011 | |
419 | * | |
420 | * Authors: | |
421 | * Anthony Liguori <aliguori@us.ibm.com> | |
422 | * | |
423 | * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. | |
424 | * See the COPYING.LIB file in the top-level directory. | |
425 | * | |
426 | */ | |
427 | ||
79ee7df8 | 428 | #include "qemu-common.h" |
06d64c62 MR |
429 | #include "%(header)s" |
430 | ''', | |
431 | header=basename(h_file))) | |
432 | ||
433 | fdecl.write(mcgen(''' | |
434 | /* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */ | |
435 | ||
436 | /* | |
437 | * schema-defined QAPI visitor function | |
438 | * | |
439 | * Copyright IBM, Corp. 2011 | |
440 | * | |
441 | * Authors: | |
442 | * Anthony Liguori <aliguori@us.ibm.com> | |
443 | * | |
444 | * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. | |
445 | * See the COPYING.LIB file in the top-level directory. | |
446 | * | |
447 | */ | |
448 | ||
449 | #ifndef %(guard)s | |
450 | #define %(guard)s | |
451 | ||
7b1b5d19 | 452 | #include "qapi/visitor.h" |
06d64c62 | 453 | #include "%(prefix)sqapi-types.h" |
7c946bc4 | 454 | |
06d64c62 MR |
455 | ''', |
456 | prefix=prefix, guard=guardname(h_file))) | |
457 | ||
458 | exprs = parse_schema(sys.stdin) | |
459 | ||
7c946bc4 MR |
460 | # to avoid header dependency hell, we always generate declarations |
461 | # for built-in types in our header files and simply guard them | |
462 | fdecl.write(guardstart("QAPI_VISIT_BUILTIN_VISITOR_DECL")) | |
463 | for typename in builtin_types: | |
464 | fdecl.write(generate_declaration(typename, None, genlist=True, | |
465 | builtin_type=True)) | |
466 | fdecl.write(guardend("QAPI_VISIT_BUILTIN_VISITOR_DECL")) | |
467 | ||
468 | # ...this doesn't work for cases where we link in multiple objects that | |
469 | # have the functions defined, so we use -b option to provide control | |
470 | # over these cases | |
471 | if do_builtins: | |
472 | fdef.write(guardstart("QAPI_VISIT_BUILTIN_VISITOR_DEF")) | |
473 | for typename in builtin_types: | |
474 | fdef.write(generate_visit_list(typename, None)) | |
475 | fdef.write(guardend("QAPI_VISIT_BUILTIN_VISITOR_DEF")) | |
476 | ||
06d64c62 MR |
477 | for expr in exprs: |
478 | if expr.has_key('type'): | |
14d36307 | 479 | ret = generate_visit_struct(expr) |
06d64c62 MR |
480 | ret += generate_visit_list(expr['type'], expr['data']) |
481 | fdef.write(ret) | |
482 | ||
483 | ret = generate_declaration(expr['type'], expr['data']) | |
484 | fdecl.write(ret) | |
485 | elif expr.has_key('union'): | |
0aef92b9 | 486 | ret = generate_visit_union(expr) |
dc8fb6df | 487 | ret += generate_visit_list(expr['union'], expr['data']) |
06d64c62 MR |
488 | fdef.write(ret) |
489 | ||
490 | ret = generate_decl_enum('%sKind' % expr['union'], expr['data'].keys()) | |
491 | ret += generate_declaration(expr['union'], expr['data']) | |
492 | fdecl.write(ret) | |
493 | elif expr.has_key('enum'): | |
b9c4b48d AK |
494 | ret = generate_visit_list(expr['enum'], expr['data']) |
495 | ret += generate_visit_enum(expr['enum'], expr['data']) | |
06d64c62 MR |
496 | fdef.write(ret) |
497 | ||
498 | ret = generate_decl_enum(expr['enum'], expr['data']) | |
b9c4b48d | 499 | ret += generate_enum_declaration(expr['enum'], expr['data']) |
06d64c62 MR |
500 | fdecl.write(ret) |
501 | ||
502 | fdecl.write(''' | |
503 | #endif | |
504 | ''') | |
505 | ||
506 | fdecl.flush() | |
507 | fdecl.close() | |
508 | ||
509 | fdef.flush() | |
510 | fdef.close() |