qapi-types.py 10 KB

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