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, %(c_type)sobj, const char *name, 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, &err); 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, %(c_name)s **obj, const char *name, Error **errp) 122{ 123 Error *err = NULL; 124 125 visit_start_struct(v, (void **)obj, "%(name)s", name, 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 name=name, 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, %(c_name)s **obj, const char *name, 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, &err)) != NULL; 165 prev = &i) { 166 %(c_name)s *native_i = (%(c_name)s *)i; 167 visit_type_%(c_elt_type)s(v, &native_i->value, NULL, &err); 168 } 169 170 error_propagate(errp, err); 171 err = NULL; 172 visit_end_list(v, &err); 173out: 174 error_propagate(errp, err); 175} 176''', 177 c_name=c_name(name), c_elt_type=element_type.c_name()) 178 179 180def gen_visit_enum(name): 181 # FIXME cast from enum *obj to int * invalidly assumes enum is int 182 return mcgen(''' 183 184void visit_type_%(c_name)s(Visitor *v, %(c_name)s *obj, const char *name, Error **errp) 185{ 186 visit_type_enum(v, (int *)obj, %(c_name)s_lookup, "%(name)s", name, errp); 187} 188''', 189 c_name=c_name(name), name=name) 190 191 192def gen_visit_alternate(name, variants): 193 promote_int = 'true' 194 for var in variants.variants: 195 if var.type.alternate_qtype() == 'QTYPE_QINT': 196 promote_int = 'false' 197 198 ret = mcgen(''' 199 200void visit_type_%(c_name)s(Visitor *v, %(c_name)s **obj, const char *name, Error **errp) 201{ 202 Error *err = NULL; 203 204 visit_start_implicit_struct(v, (void**) obj, sizeof(%(c_name)s), &err); 205 if (err) { 206 goto out; 207 } 208 visit_get_next_type(v, &(*obj)->type, %(promote_int)s, name, &err); 209 if (err) { 210 goto out_obj; 211 } 212 switch ((*obj)->type) { 213''', 214 c_name=c_name(name), promote_int=promote_int) 215 216 for var in variants.variants: 217 ret += mcgen(''' 218 case %(case)s: 219 visit_type_%(c_type)s(v, &(*obj)->u.%(c_name)s, name, &err); 220 break; 221''', 222 case=var.type.alternate_qtype(), 223 c_type=var.type.c_name(), 224 c_name=c_name(var.name)) 225 226 ret += mcgen(''' 227 default: 228 error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null", 229 "%(name)s"); 230 } 231out_obj: 232 error_propagate(errp, err); 233 err = NULL; 234 visit_end_implicit_struct(v, &err); 235out: 236 error_propagate(errp, err); 237} 238''', 239 name=name) 240 241 return ret 242 243 244def gen_visit_union(name, base, variants): 245 ret = '' 246 247 if base: 248 ret += gen_visit_fields_decl(base) 249 250 for var in variants.variants: 251 # Ugly special case for simple union TODO get rid of it 252 if not var.simple_union_type(): 253 ret += gen_visit_implicit_struct(var.type) 254 255 ret += mcgen(''' 256 257void visit_type_%(c_name)s(Visitor *v, %(c_name)s **obj, const char *name, Error **errp) 258{ 259 Error *err = NULL; 260 261 visit_start_struct(v, (void **)obj, "%(name)s", name, sizeof(%(c_name)s), &err); 262 if (err) { 263 goto out; 264 } 265 if (!*obj) { 266 goto out_obj; 267 } 268''', 269 c_name=c_name(name), name=name) 270 271 if base: 272 ret += mcgen(''' 273 visit_type_%(c_name)s_fields(v, (%(c_name)s **)obj, &err); 274''', 275 c_name=base.c_name()) 276 else: 277 ret += mcgen(''' 278 visit_type_%(c_type)s(v, &(*obj)->%(c_name)s, "%(name)s", &err); 279''', 280 c_type=variants.tag_member.type.c_name(), 281 c_name=c_name(variants.tag_member.name), 282 name=variants.tag_member.name) 283 ret += gen_err_check(label='out_obj') 284 ret += mcgen(''' 285 if (!visit_start_union(v, !!(*obj)->u.data, &err) || err) { 286 goto out_obj; 287 } 288 switch ((*obj)->%(c_name)s) { 289''', 290 c_name=c_name(variants.tag_member.name)) 291 292 for var in variants.variants: 293 # TODO ugly special case for simple union 294 simple_union_type = var.simple_union_type() 295 ret += mcgen(''' 296 case %(case)s: 297''', 298 case=c_enum_const(variants.tag_member.type.name, 299 var.name)) 300 if simple_union_type: 301 ret += mcgen(''' 302 visit_type_%(c_type)s(v, &(*obj)->u.%(c_name)s, "data", &err); 303''', 304 c_type=simple_union_type.c_name(), 305 c_name=c_name(var.name)) 306 else: 307 ret += mcgen(''' 308 visit_type_implicit_%(c_type)s(v, &(*obj)->u.%(c_name)s, &err); 309''', 310 c_type=var.type.c_name(), 311 c_name=c_name(var.name)) 312 ret += mcgen(''' 313 break; 314''') 315 316 ret += mcgen(''' 317 default: 318 abort(); 319 } 320out_obj: 321 error_propagate(errp, err); 322 err = NULL; 323 visit_end_struct(v, &err); 324out: 325 error_propagate(errp, err); 326} 327''') 328 329 return ret 330 331 332class QAPISchemaGenVisitVisitor(QAPISchemaVisitor): 333 def __init__(self): 334 self.decl = None 335 self.defn = None 336 self._btin = None 337 338 def visit_begin(self, schema): 339 self.decl = '' 340 self.defn = '' 341 self._btin = guardstart('QAPI_VISIT_BUILTIN') 342 343 def visit_end(self): 344 # To avoid header dependency hell, we always generate 345 # declarations for built-in types in our header files and 346 # simply guard them. See also do_builtins (command line 347 # option -b). 348 self._btin += guardend('QAPI_VISIT_BUILTIN') 349 self.decl = self._btin + self.decl 350 self._btin = None 351 352 def visit_needed(self, entity): 353 # Visit everything except implicit objects 354 return not (entity.is_implicit() and 355 isinstance(entity, QAPISchemaObjectType)) 356 357 def visit_enum_type(self, name, info, values, prefix): 358 # Special case for our lone builtin enum type 359 # TODO use something cleaner than existence of info 360 if not info: 361 self._btin += gen_visit_decl(name, scalar=True) 362 if do_builtins: 363 self.defn += gen_visit_enum(name) 364 else: 365 self.decl += gen_visit_decl(name, scalar=True) 366 self.defn += gen_visit_enum(name) 367 368 def visit_array_type(self, name, info, element_type): 369 decl = gen_visit_decl(name) 370 defn = gen_visit_list(name, element_type) 371 if isinstance(element_type, QAPISchemaBuiltinType): 372 self._btin += decl 373 if do_builtins: 374 self.defn += defn 375 else: 376 self.decl += decl 377 self.defn += defn 378 379 def visit_object_type(self, name, info, base, members, variants): 380 self.decl += gen_visit_decl(name) 381 if variants: 382 if members: 383 # Members other than variants.tag_member not implemented 384 assert len(members) == 1 385 assert members[0] == variants.tag_member 386 self.defn += gen_visit_union(name, base, variants) 387 else: 388 self.defn += gen_visit_struct(name, base, members) 389 390 def visit_alternate_type(self, name, info, variants): 391 self.decl += gen_visit_decl(name) 392 self.defn += gen_visit_alternate(name, variants) 393 394# If you link code generated from multiple schemata, you want only one 395# instance of the code for built-in types. Generate it only when 396# do_builtins, enabled by command line option -b. See also 397# QAPISchemaGenVisitVisitor.visit_end(). 398do_builtins = False 399 400(input_file, output_dir, do_c, do_h, prefix, opts) = \ 401 parse_command_line("b", ["builtins"]) 402 403for o, a in opts: 404 if o in ("-b", "--builtins"): 405 do_builtins = True 406 407c_comment = ''' 408/* 409 * schema-defined QAPI visitor functions 410 * 411 * Copyright IBM, Corp. 2011 412 * 413 * Authors: 414 * Anthony Liguori <aliguori@us.ibm.com> 415 * 416 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. 417 * See the COPYING.LIB file in the top-level directory. 418 * 419 */ 420''' 421h_comment = ''' 422/* 423 * schema-defined QAPI visitor functions 424 * 425 * Copyright IBM, Corp. 2011 426 * 427 * Authors: 428 * Anthony Liguori <aliguori@us.ibm.com> 429 * 430 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. 431 * See the COPYING.LIB file in the top-level directory. 432 * 433 */ 434''' 435 436(fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix, 437 'qapi-visit.c', 'qapi-visit.h', 438 c_comment, h_comment) 439 440fdef.write(mcgen(''' 441#include "qemu-common.h" 442#include "%(prefix)sqapi-visit.h" 443''', 444 prefix=prefix)) 445 446fdecl.write(mcgen(''' 447#include "qapi/visitor.h" 448#include "qapi/qmp/qerror.h" 449#include "%(prefix)sqapi-types.h" 450 451''', 452 prefix=prefix)) 453 454schema = QAPISchema(input_file) 455gen = QAPISchemaGenVisitVisitor() 456schema.visit(gen) 457fdef.write(gen.defn) 458fdecl.write(gen.decl) 459 460close_output(fdef, fdecl) 461