types.py (11255B)
1 """ 2 QAPI types generator 3 4 Copyright IBM, Corp. 2011 5 Copyright (c) 2013-2018 Red Hat Inc. 6 7 Authors: 8 Anthony Liguori <aliguori@us.ibm.com> 9 Michael Roth <mdroth@linux.vnet.ibm.com> 10 Markus Armbruster <armbru@redhat.com> 11 12 This work is licensed under the terms of the GNU GPL, version 2. 13 # See the COPYING file in the top-level directory. 14 """ 15 16 from typing import List, Optional 17 18 from .common import c_enum_const, c_name, mcgen 19 from .gen import ( 20 QAPISchemaModularCVisitor, 21 gen_special_features, 22 ifcontext, 23 ) 24 from .schema import ( 25 QAPISchema, 26 QAPISchemaEnumMember, 27 QAPISchemaFeature, 28 QAPISchemaIfCond, 29 QAPISchemaObjectType, 30 QAPISchemaObjectTypeMember, 31 QAPISchemaType, 32 QAPISchemaVariants, 33 ) 34 from .source import QAPISourceInfo 35 36 37 # variants must be emitted before their container; track what has already 38 # been output 39 objects_seen = set() 40 41 42 def gen_enum_lookup(name: str, 43 members: List[QAPISchemaEnumMember], 44 prefix: Optional[str] = None) -> str: 45 max_index = c_enum_const(name, '_MAX', prefix) 46 feats = '' 47 ret = mcgen(''' 48 49 const QEnumLookup %(c_name)s_lookup = { 50 .array = (const char *const[]) { 51 ''', 52 c_name=c_name(name)) 53 for memb in members: 54 ret += memb.ifcond.gen_if() 55 index = c_enum_const(name, memb.name, prefix) 56 ret += mcgen(''' 57 [%(index)s] = "%(name)s", 58 ''', 59 index=index, name=memb.name) 60 ret += memb.ifcond.gen_endif() 61 62 special_features = gen_special_features(memb.features) 63 if special_features != '0': 64 feats += mcgen(''' 65 [%(index)s] = %(special_features)s, 66 ''', 67 index=index, special_features=special_features) 68 69 if feats: 70 ret += mcgen(''' 71 }, 72 .special_features = (const unsigned char[%(max_index)s]) { 73 ''', 74 max_index=max_index) 75 ret += feats 76 77 ret += mcgen(''' 78 }, 79 .size = %(max_index)s 80 }; 81 ''', 82 max_index=max_index) 83 return ret 84 85 86 def gen_enum(name: str, 87 members: List[QAPISchemaEnumMember], 88 prefix: Optional[str] = None) -> str: 89 # append automatically generated _MAX value 90 enum_members = members + [QAPISchemaEnumMember('_MAX', None)] 91 92 ret = mcgen(''' 93 94 typedef enum %(c_name)s { 95 ''', 96 c_name=c_name(name)) 97 98 for memb in enum_members: 99 ret += memb.ifcond.gen_if() 100 ret += mcgen(''' 101 %(c_enum)s, 102 ''', 103 c_enum=c_enum_const(name, memb.name, prefix)) 104 ret += memb.ifcond.gen_endif() 105 106 ret += mcgen(''' 107 } %(c_name)s; 108 ''', 109 c_name=c_name(name)) 110 111 ret += mcgen(''' 112 113 #define %(c_name)s_str(val) \\ 114 qapi_enum_lookup(&%(c_name)s_lookup, (val)) 115 116 extern const QEnumLookup %(c_name)s_lookup; 117 ''', 118 c_name=c_name(name)) 119 return ret 120 121 122 def gen_fwd_object_or_array(name: str) -> str: 123 return mcgen(''' 124 125 typedef struct %(c_name)s %(c_name)s; 126 ''', 127 c_name=c_name(name)) 128 129 130 def gen_array(name: str, element_type: QAPISchemaType) -> str: 131 return mcgen(''' 132 133 struct %(c_name)s { 134 %(c_name)s *next; 135 %(c_type)s value; 136 }; 137 ''', 138 c_name=c_name(name), c_type=element_type.c_type()) 139 140 141 def gen_struct_members(members: List[QAPISchemaObjectTypeMember]) -> str: 142 ret = '' 143 for memb in members: 144 ret += memb.ifcond.gen_if() 145 if memb.optional: 146 ret += mcgen(''' 147 bool has_%(c_name)s; 148 ''', 149 c_name=c_name(memb.name)) 150 ret += mcgen(''' 151 %(c_type)s %(c_name)s; 152 ''', 153 c_type=memb.type.c_type(), c_name=c_name(memb.name)) 154 ret += memb.ifcond.gen_endif() 155 return ret 156 157 158 def gen_object(name: str, ifcond: QAPISchemaIfCond, 159 base: Optional[QAPISchemaObjectType], 160 members: List[QAPISchemaObjectTypeMember], 161 variants: Optional[QAPISchemaVariants]) -> str: 162 if name in objects_seen: 163 return '' 164 objects_seen.add(name) 165 166 ret = '' 167 for var in variants.variants if variants else (): 168 obj = var.type 169 if not isinstance(obj, QAPISchemaObjectType): 170 continue 171 ret += gen_object(obj.name, obj.ifcond, obj.base, 172 obj.local_members, obj.variants) 173 174 ret += mcgen(''' 175 176 ''') 177 ret += ifcond.gen_if() 178 ret += mcgen(''' 179 struct %(c_name)s { 180 ''', 181 c_name=c_name(name)) 182 183 if base: 184 if not base.is_implicit(): 185 ret += mcgen(''' 186 /* Members inherited from %(c_name)s: */ 187 ''', 188 c_name=base.c_name()) 189 ret += gen_struct_members(base.members) 190 if not base.is_implicit(): 191 ret += mcgen(''' 192 /* Own members: */ 193 ''') 194 ret += gen_struct_members(members) 195 196 if variants: 197 ret += gen_variants(variants) 198 199 # Make sure that all structs have at least one member; this avoids 200 # potential issues with attempting to malloc space for zero-length 201 # structs in C, and also incompatibility with C++ (where an empty 202 # struct is size 1). 203 if (not base or base.is_empty()) and not members and not variants: 204 ret += mcgen(''' 205 char qapi_dummy_for_empty_struct; 206 ''') 207 208 ret += mcgen(''' 209 }; 210 ''') 211 ret += ifcond.gen_endif() 212 213 return ret 214 215 216 def gen_upcast(name: str, base: QAPISchemaObjectType) -> str: 217 # C makes const-correctness ugly. We have to cast away const to let 218 # this function work for both const and non-const obj. 219 return mcgen(''' 220 221 static inline %(base)s *qapi_%(c_name)s_base(const %(c_name)s *obj) 222 { 223 return (%(base)s *)obj; 224 } 225 ''', 226 c_name=c_name(name), base=base.c_name()) 227 228 229 def gen_variants(variants: QAPISchemaVariants) -> str: 230 ret = mcgen(''' 231 union { /* union tag is @%(c_name)s */ 232 ''', 233 c_name=c_name(variants.tag_member.name)) 234 235 for var in variants.variants: 236 if var.type.name == 'q_empty': 237 continue 238 ret += var.ifcond.gen_if() 239 ret += mcgen(''' 240 %(c_type)s %(c_name)s; 241 ''', 242 c_type=var.type.c_unboxed_type(), 243 c_name=c_name(var.name)) 244 ret += var.ifcond.gen_endif() 245 246 ret += mcgen(''' 247 } u; 248 ''') 249 250 return ret 251 252 253 def gen_type_cleanup_decl(name: str) -> str: 254 ret = mcgen(''' 255 256 void qapi_free_%(c_name)s(%(c_name)s *obj); 257 G_DEFINE_AUTOPTR_CLEANUP_FUNC(%(c_name)s, qapi_free_%(c_name)s) 258 ''', 259 c_name=c_name(name)) 260 return ret 261 262 263 def gen_type_cleanup(name: str) -> str: 264 ret = mcgen(''' 265 266 void qapi_free_%(c_name)s(%(c_name)s *obj) 267 { 268 Visitor *v; 269 270 if (!obj) { 271 return; 272 } 273 274 v = qapi_dealloc_visitor_new(); 275 visit_type_%(c_name)s(v, NULL, &obj, NULL); 276 visit_free(v); 277 } 278 ''', 279 c_name=c_name(name)) 280 return ret 281 282 283 class QAPISchemaGenTypeVisitor(QAPISchemaModularCVisitor): 284 285 def __init__(self, prefix: str): 286 super().__init__( 287 prefix, 'qapi-types', ' * Schema-defined QAPI types', 288 ' * Built-in QAPI types', __doc__) 289 290 def _begin_builtin_module(self) -> None: 291 self._genc.preamble_add(mcgen(''' 292 #include "qemu/osdep.h" 293 #include "qapi/dealloc-visitor.h" 294 #include "qapi/qapi-builtin-types.h" 295 #include "qapi/qapi-builtin-visit.h" 296 ''')) 297 self._genh.preamble_add(mcgen(''' 298 #include "qapi/util.h" 299 ''')) 300 301 def _begin_user_module(self, name: str) -> None: 302 types = self._module_basename('qapi-types', name) 303 visit = self._module_basename('qapi-visit', name) 304 self._genc.preamble_add(mcgen(''' 305 #include "qemu/osdep.h" 306 #include "qapi/dealloc-visitor.h" 307 #include "%(types)s.h" 308 #include "%(visit)s.h" 309 ''', 310 types=types, visit=visit)) 311 self._genh.preamble_add(mcgen(''' 312 #include "qapi/qapi-builtin-types.h" 313 ''')) 314 315 def visit_begin(self, schema: QAPISchema) -> None: 316 # gen_object() is recursive, ensure it doesn't visit the empty type 317 objects_seen.add(schema.the_empty_object_type.name) 318 319 def _gen_type_cleanup(self, name: str) -> None: 320 self._genh.add(gen_type_cleanup_decl(name)) 321 self._genc.add(gen_type_cleanup(name)) 322 323 def visit_enum_type(self, 324 name: str, 325 info: Optional[QAPISourceInfo], 326 ifcond: QAPISchemaIfCond, 327 features: List[QAPISchemaFeature], 328 members: List[QAPISchemaEnumMember], 329 prefix: Optional[str]) -> None: 330 with ifcontext(ifcond, self._genh, self._genc): 331 self._genh.preamble_add(gen_enum(name, members, prefix)) 332 self._genc.add(gen_enum_lookup(name, members, prefix)) 333 334 def visit_array_type(self, 335 name: str, 336 info: Optional[QAPISourceInfo], 337 ifcond: QAPISchemaIfCond, 338 element_type: QAPISchemaType) -> None: 339 with ifcontext(ifcond, self._genh, self._genc): 340 self._genh.preamble_add(gen_fwd_object_or_array(name)) 341 self._genh.add(gen_array(name, element_type)) 342 self._gen_type_cleanup(name) 343 344 def visit_object_type(self, 345 name: str, 346 info: Optional[QAPISourceInfo], 347 ifcond: QAPISchemaIfCond, 348 features: List[QAPISchemaFeature], 349 base: Optional[QAPISchemaObjectType], 350 members: List[QAPISchemaObjectTypeMember], 351 variants: Optional[QAPISchemaVariants]) -> None: 352 # Nothing to do for the special empty builtin 353 if name == 'q_empty': 354 return 355 with ifcontext(ifcond, self._genh): 356 self._genh.preamble_add(gen_fwd_object_or_array(name)) 357 self._genh.add(gen_object(name, ifcond, base, members, variants)) 358 with ifcontext(ifcond, self._genh, self._genc): 359 if base and not base.is_implicit(): 360 self._genh.add(gen_upcast(name, base)) 361 # TODO Worth changing the visitor signature, so we could 362 # directly use rather than repeat type.is_implicit()? 363 if not name.startswith('q_'): 364 # implicit types won't be directly allocated/freed 365 self._gen_type_cleanup(name) 366 367 def visit_alternate_type(self, 368 name: str, 369 info: Optional[QAPISourceInfo], 370 ifcond: QAPISchemaIfCond, 371 features: List[QAPISchemaFeature], 372 variants: QAPISchemaVariants) -> None: 373 with ifcontext(ifcond, self._genh): 374 self._genh.preamble_add(gen_fwd_object_or_array(name)) 375 self._genh.add(gen_object(name, ifcond, None, 376 [variants.tag_member], variants)) 377 with ifcontext(ifcond, self._genh, self._genc): 378 self._gen_type_cleanup(name) 379 380 381 def gen_types(schema: QAPISchema, 382 output_dir: str, 383 prefix: str, 384 opt_builtins: bool) -> None: 385 vis = QAPISchemaGenTypeVisitor(prefix) 386 schema.visit(vis) 387 vis.write(output_dir, opt_builtins)