1# 2# QAPI visitor generator 3# 4# Copyright IBM, Corp. 2011 5# Copyright (C) 2014-2016 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 15from qapi import * 16import re 17 18# visit_type_FOO_implicit() is emitted as needed; track if it has already 19# been output. 20implicit_structs_seen = set() 21 22# visit_type_FOO_fields() is always emitted; track if a forward declaration 23# or implementation has already been output. 24struct_fields_seen = set() 25 26 27def gen_visit_decl(name, scalar=False): 28 c_type = c_name(name) + ' *' 29 if not scalar: 30 c_type += '*' 31 return mcgen(''' 32void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_type)sobj, Error **errp); 33''', 34 c_name=c_name(name), c_type=c_type) 35 36 37def gen_visit_fields_decl(typ): 38 ret = '' 39 if typ.name not in struct_fields_seen: 40 ret += mcgen(''' 41 42static void visit_type_%(c_type)s_fields(Visitor *v, %(c_type)s **obj, Error **errp); 43''', 44 c_type=typ.c_name()) 45 struct_fields_seen.add(typ.name) 46 return ret 47 48 49def gen_visit_implicit_struct(typ): 50 if typ in implicit_structs_seen: 51 return '' 52 implicit_structs_seen.add(typ) 53 54 ret = gen_visit_fields_decl(typ) 55 56 ret += mcgen(''' 57 58static void visit_type_implicit_%(c_type)s(Visitor *v, %(c_type)s **obj, Error **errp) 59{ 60 Error *err = NULL; 61 62 visit_start_implicit_struct(v, (void **)obj, sizeof(%(c_type)s), &err); 63 if (!err) { 64 visit_type_%(c_type)s_fields(v, obj, errp); 65 visit_end_implicit_struct(v); 66 } 67 error_propagate(errp, err); 68} 69''', 70 c_type=typ.c_name()) 71 return ret 72 73 74def gen_visit_struct_fields(name, base, members): 75 ret = '' 76 77 if base: 78 ret += gen_visit_fields_decl(base) 79 80 struct_fields_seen.add(name) 81 ret += mcgen(''' 82 83static void visit_type_%(c_name)s_fields(Visitor *v, %(c_name)s **obj, Error **errp) 84{ 85 Error *err = NULL; 86 87''', 88 c_name=c_name(name)) 89 90 if base: 91 ret += mcgen(''' 92 visit_type_%(c_type)s_fields(v, (%(c_type)s **)obj, &err); 93''', 94 c_type=base.c_name()) 95 ret += gen_err_check() 96 97 ret += gen_visit_fields(members, prefix='(*obj)->') 98 99 # 'goto out' produced for base, and by gen_visit_fields() for each member 100 if base or members: 101 ret += mcgen(''' 102 103out: 104''') 105 ret += mcgen(''' 106 error_propagate(errp, err); 107} 108''') 109 return ret 110 111 112def gen_visit_struct(name, base, members): 113 ret = gen_visit_struct_fields(name, base, members) 114 115 # FIXME: if *obj is NULL on entry, and visit_start_struct() assigns to 116 # *obj, but then visit_type_FOO_fields() fails, we should clean up *obj 117 # rather than leaving it non-NULL. As currently written, the caller must 118 # call qapi_free_FOO() to avoid a memory leak of the partial FOO. 119 ret += mcgen(''' 120 121void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp) 122{ 123 Error *err = NULL; 124 125 visit_start_struct(v, name, (void **)obj, sizeof(%(c_name)s), &err); 126 if (err) { 127 goto out; 128 } 129 if (!*obj) { 130 goto out_obj; 131 } 132 visit_type_%(c_name)s_fields(v, obj, &err); 133 error_propagate(errp, err); 134 err = NULL; 135out_obj: 136 visit_end_struct(v, &err); 137out: 138 error_propagate(errp, err); 139} 140''', 141 c_name=c_name(name)) 142 143 return ret 144 145 146def gen_visit_list(name, element_type): 147 # FIXME: if *obj is NULL on entry, and the first visit_next_list() 148 # assigns to *obj, while a later one fails, we should clean up *obj 149 # rather than leaving it non-NULL. As currently written, the caller must 150 # call qapi_free_FOOList() to avoid a memory leak of the partial FOOList. 151 return mcgen(''' 152 153void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp) 154{ 155 Error *err = NULL; 156 GenericList *i, **prev; 157 158 visit_start_list(v, name, &err); 159 if (err) { 160 goto out; 161 } 162 163 for (prev = (GenericList **)obj; 164 !err && (i = visit_next_list(v, prev)) != NULL; 165 prev = &i) { 166 %(c_name)s *native_i = (%(c_name)s *)i; 167 visit_type_%(c_elt_type)s(v, NULL, &native_i->value, &err); 168 } 169 170 visit_end_list(v); 171out: 172 error_propagate(errp, err); 173} 174''', 175 c_name=c_name(name), c_elt_type=element_type.c_name()) 176 177 178def gen_visit_enum(name): 179 return mcgen(''' 180 181void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s *obj, Error **errp) 182{ 183 int value = *obj; 184 visit_type_enum(v, name, &value, %(c_name)s_lookup, errp); 185 *obj = value; 186} 187''', 188 c_name=c_name(name)) 189 190 191def gen_visit_alternate(name, variants): 192 promote_int = 'true' 193 for var in variants.variants: 194 if var.type.alternate_qtype() == 'QTYPE_QINT': 195 promote_int = 'false' 196 197 ret = mcgen(''' 198 199void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp) 200{ 201 Error *err = NULL; 202 203 visit_start_implicit_struct(v, (void**) obj, sizeof(%(c_name)s), &err); 204 if (err) { 205 goto out; 206 } 207 visit_get_next_type(v, name, &(*obj)->type, %(promote_int)s, &err); 208 if (err) { 209 goto out_obj; 210 } 211 switch ((*obj)->type) { 212''', 213 c_name=c_name(name), promote_int=promote_int) 214 215 for var in variants.variants: 216 ret += mcgen(''' 217 case %(case)s: 218 visit_type_%(c_type)s(v, name, &(*obj)->u.%(c_name)s, &err); 219 break; 220''', 221 case=var.type.alternate_qtype(), 222 c_type=var.type.c_name(), 223 c_name=c_name(var.name)) 224 225 ret += mcgen(''' 226 default: 227 error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null", 228 "%(name)s"); 229 } 230out_obj: 231 visit_end_implicit_struct(v); 232out: 233 error_propagate(errp, err); 234} 235''', 236 name=name) 237 238 return ret 239 240 241def gen_visit_union(name, base, variants): 242 ret = '' 243 244 if base: 245 ret += gen_visit_fields_decl(base) 246 247 for var in variants.variants: 248 # Ugly special case for simple union TODO get rid of it 249 if not var.simple_union_type(): 250 ret += gen_visit_implicit_struct(var.type) 251 252 ret += mcgen(''' 253 254void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp) 255{ 256 Error *err = NULL; 257 258 visit_start_struct(v, name, (void **)obj, sizeof(%(c_name)s), &err); 259 if (err) { 260 goto out; 261 } 262 if (!*obj) { 263 goto out_obj; 264 } 265''', 266 c_name=c_name(name)) 267 268 if base: 269 ret += mcgen(''' 270 visit_type_%(c_name)s_fields(v, (%(c_name)s **)obj, &err); 271''', 272 c_name=base.c_name()) 273 else: 274 ret += mcgen(''' 275 visit_type_%(c_type)s(v, "%(name)s", &(*obj)->%(c_name)s, &err); 276''', 277 c_type=variants.tag_member.type.c_name(), 278 c_name=c_name(variants.tag_member.name), 279 name=variants.tag_member.name) 280 ret += gen_err_check(label='out_obj') 281 ret += mcgen(''' 282 if (!visit_start_union(v, !!(*obj)->u.data, &err) || err) { 283 goto out_obj; 284 } 285 switch ((*obj)->%(c_name)s) { 286''', 287 c_name=c_name(variants.tag_member.name)) 288 289 for var in variants.variants: 290 # TODO ugly special case for simple union 291 simple_union_type = var.simple_union_type() 292 ret += mcgen(''' 293 case %(case)s: 294''', 295 case=c_enum_const(variants.tag_member.type.name, 296 var.name)) 297 if simple_union_type: 298 ret += mcgen(''' 299 visit_type_%(c_type)s(v, "data", &(*obj)->u.%(c_name)s, &err); 300''', 301 c_type=simple_union_type.c_name(), 302 c_name=c_name(var.name)) 303 else: 304 ret += mcgen(''' 305 visit_type_implicit_%(c_type)s(v, &(*obj)->u.%(c_name)s, &err); 306''', 307 c_type=var.type.c_name(), 308 c_name=c_name(var.name)) 309 ret += mcgen(''' 310 break; 311''') 312 313 ret += mcgen(''' 314 default: 315 abort(); 316 } 317out_obj: 318 error_propagate(errp, err); 319 err = NULL; 320 visit_end_struct(v, &err); 321out: 322 error_propagate(errp, err); 323} 324''') 325 326 return ret 327 328 329class QAPISchemaGenVisitVisitor(QAPISchemaVisitor): 330 def __init__(self): 331 self.decl = None 332 self.defn = None 333 self._btin = None 334 335 def visit_begin(self, schema): 336 self.decl = '' 337 self.defn = '' 338 self._btin = guardstart('QAPI_VISIT_BUILTIN') 339 340 def visit_end(self): 341 # To avoid header dependency hell, we always generate 342 # declarations for built-in types in our header files and 343 # simply guard them. See also do_builtins (command line 344 # option -b). 345 self._btin += guardend('QAPI_VISIT_BUILTIN') 346 self.decl = self._btin + self.decl 347 self._btin = None 348 349 def visit_needed(self, entity): 350 # Visit everything except implicit objects 351 return not (entity.is_implicit() and 352 isinstance(entity, QAPISchemaObjectType)) 353 354 def visit_enum_type(self, name, info, values, prefix): 355 # Special case for our lone builtin enum type 356 # TODO use something cleaner than existence of info 357 if not info: 358 self._btin += gen_visit_decl(name, scalar=True) 359 if do_builtins: 360 self.defn += gen_visit_enum(name) 361 else: 362 self.decl += gen_visit_decl(name, scalar=True) 363 self.defn += gen_visit_enum(name) 364 365 def visit_array_type(self, name, info, element_type): 366 decl = gen_visit_decl(name) 367 defn = gen_visit_list(name, element_type) 368 if isinstance(element_type, QAPISchemaBuiltinType): 369 self._btin += decl 370 if do_builtins: 371 self.defn += defn 372 else: 373 self.decl += decl 374 self.defn += defn 375 376 def visit_object_type(self, name, info, base, members, variants): 377 self.decl += gen_visit_decl(name) 378 if variants: 379 if members: 380 # Members other than variants.tag_member not implemented 381 assert len(members) == 1 382 assert members[0] == variants.tag_member 383 self.defn += gen_visit_union(name, base, variants) 384 else: 385 self.defn += gen_visit_struct(name, base, members) 386 387 def visit_alternate_type(self, name, info, variants): 388 self.decl += gen_visit_decl(name) 389 self.defn += gen_visit_alternate(name, variants) 390 391# If you link code generated from multiple schemata, you want only one 392# instance of the code for built-in types. Generate it only when 393# do_builtins, enabled by command line option -b. See also 394# QAPISchemaGenVisitVisitor.visit_end(). 395do_builtins = False 396 397(input_file, output_dir, do_c, do_h, prefix, opts) = \ 398 parse_command_line("b", ["builtins"]) 399 400for o, a in opts: 401 if o in ("-b", "--builtins"): 402 do_builtins = True 403 404c_comment = ''' 405/* 406 * schema-defined QAPI visitor functions 407 * 408 * Copyright IBM, Corp. 2011 409 * 410 * Authors: 411 * Anthony Liguori <aliguori@us.ibm.com> 412 * 413 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. 414 * See the COPYING.LIB file in the top-level directory. 415 * 416 */ 417''' 418h_comment = ''' 419/* 420 * schema-defined QAPI visitor functions 421 * 422 * Copyright IBM, Corp. 2011 423 * 424 * Authors: 425 * Anthony Liguori <aliguori@us.ibm.com> 426 * 427 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. 428 * See the COPYING.LIB file in the top-level directory. 429 * 430 */ 431''' 432 433(fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix, 434 'qapi-visit.c', 'qapi-visit.h', 435 c_comment, h_comment) 436 437fdef.write(mcgen(''' 438#include "qemu/osdep.h" 439#include "qemu-common.h" 440#include "%(prefix)sqapi-visit.h" 441''', 442 prefix=prefix)) 443 444fdecl.write(mcgen(''' 445#include "qapi/visitor.h" 446#include "qapi/qmp/qerror.h" 447#include "%(prefix)sqapi-types.h" 448 449''', 450 prefix=prefix)) 451 452schema = QAPISchema(input_file) 453gen = QAPISchemaGenVisitVisitor() 454schema.visit(gen) 455fdef.write(gen.defn) 456fdecl.write(gen.decl) 457 458close_output(fdef, fdecl) 459