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