]>
Commit | Line | Data |
---|---|---|
fb3182ce MR |
1 | # |
2 | # QAPI types generator | |
3 | # | |
4 | # Copyright IBM, Corp. 2011 | |
5 | # | |
6 | # Authors: | |
7 | # Anthony Liguori <aliguori@us.ibm.com> | |
8 | # | |
9 | # This work is licensed under the terms of the GNU GPLv2. | |
10 | # See the COPYING.LIB file in the top-level directory. | |
11 | ||
12 | from ordereddict import OrderedDict | |
13 | from qapi import * | |
14 | import sys | |
15 | import os | |
16 | import getopt | |
17 | import errno | |
18 | ||
c0afa9c5 MR |
19 | def generate_fwd_struct(name, members, builtin_type=False): |
20 | if builtin_type: | |
21 | return mcgen(''' | |
22 | ||
23 | typedef struct %(name)sList | |
24 | { | |
a678e26c MR |
25 | union { |
26 | %(type)s value; | |
27 | uint64_t padding; | |
28 | }; | |
c0afa9c5 MR |
29 | struct %(name)sList *next; |
30 | } %(name)sList; | |
31 | ''', | |
32 | type=c_type(name), | |
33 | name=name) | |
34 | ||
fb3182ce | 35 | return mcgen(''' |
c0afa9c5 | 36 | |
fb3182ce MR |
37 | typedef struct %(name)s %(name)s; |
38 | ||
39 | typedef struct %(name)sList | |
40 | { | |
a678e26c MR |
41 | union { |
42 | %(name)s *value; | |
43 | uint64_t padding; | |
44 | }; | |
fb3182ce MR |
45 | struct %(name)sList *next; |
46 | } %(name)sList; | |
47 | ''', | |
48 | name=name) | |
49 | ||
b9c4b48d AK |
50 | def generate_fwd_enum_struct(name, members): |
51 | return mcgen(''' | |
52 | typedef struct %(name)sList | |
53 | { | |
54 | %(name)s value; | |
55 | struct %(name)sList *next; | |
56 | } %(name)sList; | |
57 | ''', | |
58 | name=name) | |
59 | ||
01537030 KW |
60 | def generate_struct_fields(members): |
61 | ret = '' | |
fb3182ce MR |
62 | |
63 | for argname, argentry, optional, structured in parse_args(members): | |
64 | if optional: | |
65 | ret += mcgen(''' | |
66 | bool has_%(c_name)s; | |
67 | ''', | |
68 | c_name=c_var(argname)) | |
69 | if structured: | |
70 | push_indent() | |
71 | ret += generate_struct("", argname, argentry) | |
72 | pop_indent() | |
73 | else: | |
74 | ret += mcgen(''' | |
75 | %(c_type)s %(c_name)s; | |
76 | ''', | |
77 | c_type=c_type(argentry), c_name=c_var(argname)) | |
78 | ||
01537030 KW |
79 | return ret |
80 | ||
81 | def generate_struct(structname, fieldname, members): | |
82 | ret = mcgen(''' | |
83 | struct %(name)s | |
84 | { | |
85 | ''', | |
86 | name=structname) | |
87 | ||
88 | ret += generate_struct_fields(members) | |
89 | ||
fb3182ce MR |
90 | if len(fieldname): |
91 | fieldname = " " + fieldname | |
92 | ret += mcgen(''' | |
93 | }%(field)s; | |
94 | ''', | |
95 | field=fieldname) | |
96 | ||
97 | return ret | |
98 | ||
99 | def generate_enum_lookup(name, values): | |
100 | ret = mcgen(''' | |
101 | const char *%(name)s_lookup[] = { | |
102 | ''', | |
103 | name=name) | |
104 | i = 0 | |
105 | for value in values: | |
106 | ret += mcgen(''' | |
107 | "%(value)s", | |
108 | ''', | |
ac4ff701 | 109 | value=value) |
fb3182ce MR |
110 | |
111 | ret += mcgen(''' | |
112 | NULL, | |
113 | }; | |
114 | ||
115 | ''') | |
116 | return ret | |
117 | ||
f01f594b LC |
118 | def generate_enum_name(name): |
119 | if name.isupper(): | |
eda50a65 | 120 | return c_fun(name, False) |
f01f594b | 121 | new_name = '' |
eda50a65 | 122 | for c in c_fun(name, False): |
f01f594b LC |
123 | if c.isupper(): |
124 | new_name += '_' | |
125 | new_name += c | |
126 | return new_name.lstrip('_').upper() | |
127 | ||
fb3182ce MR |
128 | def generate_enum(name, values): |
129 | lookup_decl = mcgen(''' | |
130 | extern const char *%(name)s_lookup[]; | |
131 | ''', | |
132 | name=name) | |
133 | ||
134 | enum_decl = mcgen(''' | |
135 | typedef enum %(name)s | |
136 | { | |
137 | ''', | |
138 | name=name) | |
139 | ||
303b54b1 LC |
140 | # append automatically generated _MAX value |
141 | enum_values = values + [ 'MAX' ] | |
142 | ||
fb3182ce | 143 | i = 0 |
303b54b1 | 144 | for value in enum_values: |
fb3182ce MR |
145 | enum_decl += mcgen(''' |
146 | %(abbrev)s_%(value)s = %(i)d, | |
147 | ''', | |
148 | abbrev=de_camel_case(name).upper(), | |
f01f594b | 149 | value=generate_enum_name(value), |
fb3182ce MR |
150 | i=i) |
151 | i += 1 | |
152 | ||
153 | enum_decl += mcgen(''' | |
154 | } %(name)s; | |
155 | ''', | |
156 | name=name) | |
157 | ||
158 | return lookup_decl + enum_decl | |
159 | ||
69dd62df KW |
160 | def generate_anon_union_qtypes(expr): |
161 | ||
162 | name = expr['union'] | |
163 | members = expr['data'] | |
164 | ||
165 | ret = mcgen(''' | |
166 | const int %(name)s_qtypes[QTYPE_MAX] = { | |
167 | ''', | |
168 | name=name) | |
169 | ||
170 | for key in members: | |
171 | qapi_type = members[key] | |
172 | if builtin_type_qtypes.has_key(qapi_type): | |
173 | qtype = builtin_type_qtypes[qapi_type] | |
174 | elif find_struct(qapi_type): | |
175 | qtype = "QTYPE_QDICT" | |
176 | elif find_union(qapi_type): | |
177 | qtype = "QTYPE_QDICT" | |
178 | else: | |
179 | assert False, "Invalid anonymous union member" | |
180 | ||
181 | ret += mcgen(''' | |
182 | [ %(qtype)s ] = %(abbrev)s_KIND_%(enum)s, | |
183 | ''', | |
184 | qtype = qtype, | |
185 | abbrev = de_camel_case(name).upper(), | |
186 | enum = c_fun(de_camel_case(key),False).upper()) | |
187 | ||
188 | ret += mcgen(''' | |
189 | }; | |
190 | ''') | |
191 | return ret | |
192 | ||
193 | ||
e2503f5e KW |
194 | def generate_union(expr): |
195 | ||
196 | name = expr['union'] | |
197 | typeinfo = expr['data'] | |
50f2bdc7 | 198 | |
e2503f5e | 199 | base = expr.get('base') |
50f2bdc7 | 200 | discriminator = expr.get('discriminator') |
e2503f5e | 201 | |
fb3182ce MR |
202 | ret = mcgen(''' |
203 | struct %(name)s | |
204 | { | |
205 | %(name)sKind kind; | |
206 | union { | |
dc8fb6df | 207 | void *data; |
fb3182ce MR |
208 | ''', |
209 | name=name) | |
210 | ||
211 | for key in typeinfo: | |
212 | ret += mcgen(''' | |
213 | %(c_type)s %(c_name)s; | |
214 | ''', | |
215 | c_type=c_type(typeinfo[key]), | |
c9da228b | 216 | c_name=c_fun(key)) |
fb3182ce MR |
217 | |
218 | ret += mcgen(''' | |
219 | }; | |
e2503f5e KW |
220 | ''') |
221 | ||
222 | if base: | |
50f2bdc7 KW |
223 | base_fields = find_struct(base)['data'] |
224 | if discriminator: | |
225 | base_fields = base_fields.copy() | |
226 | del base_fields[discriminator] | |
227 | ret += generate_struct_fields(base_fields) | |
228 | else: | |
229 | assert not discriminator | |
e2503f5e KW |
230 | |
231 | ret += mcgen(''' | |
fb3182ce MR |
232 | }; |
233 | ''') | |
69dd62df KW |
234 | if discriminator == {}: |
235 | ret += mcgen(''' | |
236 | extern const int %(name)s_qtypes[]; | |
237 | ''', | |
238 | name=name) | |
239 | ||
fb3182ce MR |
240 | |
241 | return ret | |
242 | ||
243 | def generate_type_cleanup_decl(name): | |
244 | ret = mcgen(''' | |
245 | void qapi_free_%(type)s(%(c_type)s obj); | |
246 | ''', | |
247 | c_type=c_type(name),type=name) | |
248 | return ret | |
249 | ||
250 | def generate_type_cleanup(name): | |
251 | ret = mcgen(''' | |
c0afa9c5 | 252 | |
fb3182ce MR |
253 | void qapi_free_%(type)s(%(c_type)s obj) |
254 | { | |
255 | QapiDeallocVisitor *md; | |
256 | Visitor *v; | |
257 | ||
258 | if (!obj) { | |
259 | return; | |
260 | } | |
261 | ||
262 | md = qapi_dealloc_visitor_new(); | |
263 | v = qapi_dealloc_get_visitor(md); | |
264 | visit_type_%(type)s(v, &obj, NULL, NULL); | |
265 | qapi_dealloc_visitor_cleanup(md); | |
266 | } | |
267 | ''', | |
268 | c_type=c_type(name),type=name) | |
269 | return ret | |
270 | ||
271 | ||
272 | try: | |
c0afa9c5 MR |
273 | opts, args = getopt.gnu_getopt(sys.argv[1:], "chbp:o:", |
274 | ["source", "header", "builtins", | |
275 | "prefix=", "output-dir="]) | |
fb3182ce MR |
276 | except getopt.GetoptError, err: |
277 | print str(err) | |
278 | sys.exit(1) | |
279 | ||
280 | output_dir = "" | |
281 | prefix = "" | |
282 | c_file = 'qapi-types.c' | |
283 | h_file = 'qapi-types.h' | |
284 | ||
8d3bc517 AK |
285 | do_c = False |
286 | do_h = False | |
c0afa9c5 | 287 | do_builtins = False |
8d3bc517 | 288 | |
fb3182ce MR |
289 | for o, a in opts: |
290 | if o in ("-p", "--prefix"): | |
291 | prefix = a | |
292 | elif o in ("-o", "--output-dir"): | |
293 | output_dir = a + "/" | |
8d3bc517 | 294 | elif o in ("-c", "--source"): |
8d3bc517 | 295 | do_c = True |
19bf7c87 AK |
296 | elif o in ("-h", "--header"): |
297 | do_h = True | |
c0afa9c5 MR |
298 | elif o in ("-b", "--builtins"): |
299 | do_builtins = True | |
8d3bc517 AK |
300 | |
301 | if not do_c and not do_h: | |
302 | do_c = True | |
303 | do_h = True | |
fb3182ce MR |
304 | |
305 | c_file = output_dir + prefix + c_file | |
306 | h_file = output_dir + prefix + h_file | |
307 | ||
308 | try: | |
309 | os.makedirs(output_dir) | |
310 | except os.error, e: | |
311 | if e.errno != errno.EEXIST: | |
312 | raise | |
313 | ||
8d3bc517 | 314 | def maybe_open(really, name, opt): |
8d3bc517 AK |
315 | if really: |
316 | return open(name, opt) | |
19bf7c87 AK |
317 | else: |
318 | import StringIO | |
319 | return StringIO.StringIO() | |
8d3bc517 AK |
320 | |
321 | fdef = maybe_open(do_c, c_file, 'w') | |
322 | fdecl = maybe_open(do_h, h_file, 'w') | |
fb3182ce MR |
323 | |
324 | fdef.write(mcgen(''' | |
325 | /* AUTOMATICALLY GENERATED, DO NOT MODIFY */ | |
326 | ||
327 | /* | |
328 | * deallocation functions for schema-defined QAPI types | |
329 | * | |
330 | * Copyright IBM, Corp. 2011 | |
331 | * | |
332 | * Authors: | |
333 | * Anthony Liguori <aliguori@us.ibm.com> | |
334 | * Michael Roth <mdroth@linux.vnet.ibm.com> | |
335 | * | |
336 | * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. | |
337 | * See the COPYING.LIB file in the top-level directory. | |
338 | * | |
339 | */ | |
340 | ||
7b1b5d19 | 341 | #include "qapi/dealloc-visitor.h" |
fb3182ce MR |
342 | #include "%(prefix)sqapi-types.h" |
343 | #include "%(prefix)sqapi-visit.h" | |
344 | ||
345 | ''', prefix=prefix)) | |
346 | ||
347 | fdecl.write(mcgen(''' | |
348 | /* AUTOMATICALLY GENERATED, DO NOT MODIFY */ | |
349 | ||
350 | /* | |
351 | * schema-defined QAPI types | |
352 | * | |
353 | * Copyright IBM, Corp. 2011 | |
354 | * | |
355 | * Authors: | |
356 | * Anthony Liguori <aliguori@us.ibm.com> | |
357 | * | |
358 | * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. | |
359 | * See the COPYING.LIB file in the top-level directory. | |
360 | * | |
361 | */ | |
362 | ||
363 | #ifndef %(guard)s | |
364 | #define %(guard)s | |
365 | ||
da4fea06 IM |
366 | #include <stdbool.h> |
367 | #include <stdint.h> | |
b68a8472 | 368 | |
fb3182ce MR |
369 | ''', |
370 | guard=guardname(h_file))) | |
371 | ||
372 | exprs = parse_schema(sys.stdin) | |
5dbee474 | 373 | exprs = filter(lambda expr: not expr.has_key('gen'), exprs) |
fb3182ce | 374 | |
c0afa9c5 MR |
375 | fdecl.write(guardstart("QAPI_TYPES_BUILTIN_STRUCT_DECL")) |
376 | for typename in builtin_types: | |
377 | fdecl.write(generate_fwd_struct(typename, None, builtin_type=True)) | |
378 | fdecl.write(guardend("QAPI_TYPES_BUILTIN_STRUCT_DECL")) | |
379 | ||
fb3182ce MR |
380 | for expr in exprs: |
381 | ret = "\n" | |
382 | if expr.has_key('type'): | |
383 | ret += generate_fwd_struct(expr['type'], expr['data']) | |
384 | elif expr.has_key('enum'): | |
b9c4b48d AK |
385 | ret += generate_enum(expr['enum'], expr['data']) + "\n" |
386 | ret += generate_fwd_enum_struct(expr['enum'], expr['data']) | |
fb3182ce MR |
387 | fdef.write(generate_enum_lookup(expr['enum'], expr['data'])) |
388 | elif expr.has_key('union'): | |
389 | ret += generate_fwd_struct(expr['union'], expr['data']) + "\n" | |
390 | ret += generate_enum('%sKind' % expr['union'], expr['data'].keys()) | |
dc8fb6df | 391 | fdef.write(generate_enum_lookup('%sKind' % expr['union'], expr['data'].keys())) |
69dd62df KW |
392 | if expr.get('discriminator') == {}: |
393 | fdef.write(generate_anon_union_qtypes(expr)) | |
fb3182ce MR |
394 | else: |
395 | continue | |
396 | fdecl.write(ret) | |
397 | ||
c0afa9c5 MR |
398 | # to avoid header dependency hell, we always generate declarations |
399 | # for built-in types in our header files and simply guard them | |
400 | fdecl.write(guardstart("QAPI_TYPES_BUILTIN_CLEANUP_DECL")) | |
401 | for typename in builtin_types: | |
402 | fdecl.write(generate_type_cleanup_decl(typename + "List")) | |
403 | fdecl.write(guardend("QAPI_TYPES_BUILTIN_CLEANUP_DECL")) | |
404 | ||
405 | # ...this doesn't work for cases where we link in multiple objects that | |
406 | # have the functions defined, so we use -b option to provide control | |
407 | # over these cases | |
408 | if do_builtins: | |
409 | fdef.write(guardstart("QAPI_TYPES_BUILTIN_CLEANUP_DEF")) | |
410 | for typename in builtin_types: | |
411 | fdef.write(generate_type_cleanup(typename + "List")) | |
412 | fdef.write(guardend("QAPI_TYPES_BUILTIN_CLEANUP_DEF")) | |
413 | ||
fb3182ce MR |
414 | for expr in exprs: |
415 | ret = "\n" | |
416 | if expr.has_key('type'): | |
417 | ret += generate_struct(expr['type'], "", expr['data']) + "\n" | |
75b96aca MR |
418 | ret += generate_type_cleanup_decl(expr['type'] + "List") |
419 | fdef.write(generate_type_cleanup(expr['type'] + "List") + "\n") | |
fb3182ce MR |
420 | ret += generate_type_cleanup_decl(expr['type']) |
421 | fdef.write(generate_type_cleanup(expr['type']) + "\n") | |
422 | elif expr.has_key('union'): | |
e2503f5e | 423 | ret += generate_union(expr) |
dc8fb6df PB |
424 | ret += generate_type_cleanup_decl(expr['union'] + "List") |
425 | fdef.write(generate_type_cleanup(expr['union'] + "List") + "\n") | |
426 | ret += generate_type_cleanup_decl(expr['union']) | |
427 | fdef.write(generate_type_cleanup(expr['union']) + "\n") | |
b9c4b48d AK |
428 | elif expr.has_key('enum'): |
429 | ret += generate_type_cleanup_decl(expr['enum'] + "List") | |
430 | fdef.write(generate_type_cleanup(expr['enum'] + "List") + "\n") | |
fb3182ce MR |
431 | else: |
432 | continue | |
433 | fdecl.write(ret) | |
434 | ||
435 | fdecl.write(''' | |
436 | #endif | |
437 | ''') | |
438 | ||
439 | fdecl.flush() | |
440 | fdecl.close() | |
776574d6 AL |
441 | |
442 | fdef.flush() | |
443 | fdef.close() |