scripts/qapi/visit.py

   1 """
   2 QAPI visitor generator
   3
   4 Copyright IBM, Corp. 2011
   5 Copyright (C) 2014-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 (
  19     c_enum_const,
  20     c_name,
  21     indent,
  22     mcgen,
  23 )
  24 from .gen import (
  25     QAPISchemaModularCVisitor,
  26     gen_special_features,
  27     ifcontext,
  28 )
  29 from .schema import (
  30     QAPISchema,
  31     QAPISchemaEnumMember,
  32     QAPISchemaEnumType,
  33     QAPISchemaFeature,
  34     QAPISchemaIfCond,
  35     QAPISchemaObjectType,
  36     QAPISchemaObjectTypeMember,
  37     QAPISchemaType,
  38     QAPISchemaVariants,
  39 )
  40 from .source import QAPISourceInfo
  41
  42
  43 def gen_visit_decl(name: str, scalar: bool = False) -> str:
  44     c_type = c_name(name) + ' *'
  45     if not scalar:
  46         c_type += '*'
  47     return mcgen('''
  48
  49 bool visit_type_%(c_name)s(Visitor *v, const char *name,
  50                  %(c_type)sobj, Error **errp);
  51 ''',
  52                  c_name=c_name(name), c_type=c_type)
  53
  54
  55 def gen_visit_members_decl(name: str) -> str:
  56     return mcgen('''
  57
  58 bool visit_type_%(c_name)s_members(Visitor *v, %(c_name)s *obj, Error **errp);
  59 ''',
  60                  c_name=c_name(name))
  61
  62
  63 def gen_visit_object_members(name: str,
  64                              base: Optional[QAPISchemaObjectType],
  65                              members: List[QAPISchemaObjectTypeMember],
  66                              variants: Optional[QAPISchemaVariants]) -> str:
  67     ret = mcgen('''
  68
  69 bool visit_type_%(c_name)s_members(Visitor *v, %(c_name)s *obj, Error **errp)
  70 {
  71 ''',
  72                 c_name=c_name(name))
  73
  74     sep = ''
  75     for memb in members:
  76         if memb.optional and not memb.need_has():
  77             ret += mcgen('''
  78     bool has_%(c_name)s = !!obj->%(c_name)s;
  79 ''',
  80                          c_name=c_name(memb.name))
  81             sep = '\n'
  82     ret += sep
  83
  84     if base:
  85         ret += mcgen('''
  86     if (!visit_type_%(c_type)s_members(v, (%(c_type)s *)obj, errp)) {
  87         return false;
  88     }
  89 ''',
  90                      c_type=base.c_name())
  91
  92     for memb in members:
  93         ret += memb.ifcond.gen_if()
  94         if memb.optional:
  95             has = 'has_' + c_name(memb.name)
  96             if memb.need_has():
  97                 has = 'obj->' + has
  98             ret += mcgen('''
  99     if (visit_optional(v, "%(name)s", &%(has)s)) {
 100 ''',
 101                          name=memb.name, has=has)
 102             indent.increase()
 103         special_features = gen_special_features(memb.features)
 104         if special_features != '0':
 105             ret += mcgen('''
 106     if (visit_policy_reject(v, "%(name)s", %(special_features)s, errp)) {
 107         return false;
 108     }
 109     if (!visit_policy_skip(v, "%(name)s", %(special_features)s)) {
 110 ''',
 111                          name=memb.name, special_features=special_features)
 112             indent.increase()
 113         ret += mcgen('''
 114     if (!visit_type_%(c_type)s(v, "%(name)s", &obj->%(c_name)s, errp)) {
 115         return false;
 116     }
 117 ''',
 118                      c_type=memb.type.c_name(), name=memb.name,
 119                      c_name=c_name(memb.name))
 120         if special_features != '0':
 121             indent.decrease()
 122             ret += mcgen('''
 123     }
 124 ''')
 125         if memb.optional:
 126             indent.decrease()
 127             ret += mcgen('''
 128     }
 129 ''')
 130         ret += memb.ifcond.gen_endif()
 131
 132     if variants:
 133         tag_member = variants.tag_member
 134         assert isinstance(tag_member.type, QAPISchemaEnumType)
 135
 136         ret += mcgen('''
 137     switch (obj->%(c_name)s) {
 138 ''',
 139                      c_name=c_name(tag_member.name))
 140
 141         for var in variants.variants:
 142             case_str = c_enum_const(tag_member.type.name, var.name,
 143                                     tag_member.type.prefix)
 144             ret += var.ifcond.gen_if()
 145             if var.type.name == 'q_empty':
 146                 # valid variant and nothing to do
 147                 ret += mcgen('''
 148     case %(case)s:
 149         break;
 150 ''',
 151                              case=case_str)
 152             else:
 153                 ret += mcgen('''
 154     case %(case)s:
 155         return visit_type_%(c_type)s_members(v, &obj->u.%(c_name)s, errp);
 156 ''',
 157                              case=case_str,
 158                              c_type=var.type.c_name(), c_name=c_name(var.name))
 159
 160             ret += var.ifcond.gen_endif()
 161         ret += mcgen('''
 162     default:
 163         abort();
 164     }
 165 ''')
 166
 167     ret += mcgen('''
 168     return true;
 169 }
 170 ''')
 171     return ret
 172
 173
 174 def gen_visit_list(name: str, element_type: QAPISchemaType) -> str:
 175     return mcgen('''
 176
 177 bool visit_type_%(c_name)s(Visitor *v, const char *name,
 178                  %(c_name)s **obj, Error **errp)
 179 {
 180     bool ok = false;
 181     %(c_name)s *tail;
 182     size_t size = sizeof(**obj);
 183
 184     if (!visit_start_list(v, name, (GenericList **)obj, size, errp)) {
 185         return false;
 186     }
 187
 188     for (tail = *obj; tail;
 189          tail = (%(c_name)s *)visit_next_list(v, (GenericList *)tail, size)) {
 190         if (!visit_type_%(c_elt_type)s(v, NULL, &tail->value, errp)) {
 191             goto out_obj;
 192         }
 193     }
 194
 195     ok = visit_check_list(v, errp);
 196 out_obj:
 197     visit_end_list(v, (void **)obj);
 198     if (!ok && visit_is_input(v)) {
 199         qapi_free_%(c_name)s(*obj);
 200         *obj = NULL;
 201     }
 202     return ok;
 203 }
 204 ''',
 205                  c_name=c_name(name), c_elt_type=element_type.c_name())
 206
 207
 208 def gen_visit_enum(name: str) -> str:
 209     return mcgen('''
 210
 211 bool visit_type_%(c_name)s(Visitor *v, const char *name,
 212                  %(c_name)s *obj, Error **errp)
 213 {
 214     int value = *obj;
 215     bool ok = visit_type_enum(v, name, &value, &%(c_name)s_lookup, errp);
 216     *obj = value;
 217     return ok;
 218 }
 219 ''',
 220                  c_name=c_name(name))
 221
 222
 223 def gen_visit_alternate(name: str, variants: QAPISchemaVariants) -> str:
 224     ret = mcgen('''
 225
 226 bool visit_type_%(c_name)s(Visitor *v, const char *name,
 227                  %(c_name)s **obj, Error **errp)
 228 {
 229     bool ok = false;
 230
 231     if (!visit_start_alternate(v, name, (GenericAlternate **)obj,
 232                                sizeof(**obj), errp)) {
 233         return false;
 234     }
 235     if (!*obj) {
 236         /* incomplete */
 237         assert(visit_is_dealloc(v));
 238         ok = true;
 239         goto out_obj;
 240     }
 241     switch ((*obj)->type) {
 242 ''',
 243                 c_name=c_name(name))
 244
 245     for var in variants.variants:
 246         ret += var.ifcond.gen_if()
 247         ret += mcgen('''
 248     case %(case)s:
 249 ''',
 250                      case=var.type.alternate_qtype())
 251         if isinstance(var.type, QAPISchemaObjectType):
 252             ret += mcgen('''
 253         if (!visit_start_struct(v, name, NULL, 0, errp)) {
 254             break;
 255         }
 256         if (visit_type_%(c_type)s_members(v, &(*obj)->u.%(c_name)s, errp)) {
 257             ok = visit_check_struct(v, errp);
 258         }
 259         visit_end_struct(v, NULL);
 260 ''',
 261                          c_type=var.type.c_name(),
 262                          c_name=c_name(var.name))
 263         else:
 264             ret += mcgen('''
 265         ok = visit_type_%(c_type)s(v, name, &(*obj)->u.%(c_name)s, errp);
 266 ''',
 267                          c_type=var.type.c_name(),
 268                          c_name=c_name(var.name))
 269         ret += mcgen('''
 270         break;
 271 ''')
 272         ret += var.ifcond.gen_endif()
 273
 274     ret += mcgen('''
 275     case QTYPE_NONE:
 276         abort();
 277     default:
 278         assert(visit_is_input(v));
 279         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 280                    "%(name)s");
 281         /* Avoid passing invalid *obj to qapi_free_%(c_name)s() */
 282         g_free(*obj);
 283         *obj = NULL;
 284     }
 285 out_obj:
 286     visit_end_alternate(v, (void **)obj);
 287     if (!ok && visit_is_input(v)) {
 288         qapi_free_%(c_name)s(*obj);
 289         *obj = NULL;
 290     }
 291     return ok;
 292 }
 293 ''',
 294                  name=name, c_name=c_name(name))
 295
 296     return ret
 297
 298
 299 def gen_visit_object(name: str) -> str:
 300     return mcgen('''
 301
 302 bool visit_type_%(c_name)s(Visitor *v, const char *name,
 303                  %(c_name)s **obj, Error **errp)
 304 {
 305     bool ok = false;
 306
 307     if (!visit_start_struct(v, name, (void **)obj, sizeof(%(c_name)s), errp)) {
 308         return false;
 309     }
 310     if (!*obj) {
 311         /* incomplete */
 312         assert(visit_is_dealloc(v));
 313         ok = true;
 314         goto out_obj;
 315     }
 316     if (!visit_type_%(c_name)s_members(v, *obj, errp)) {
 317         goto out_obj;
 318     }
 319     ok = visit_check_struct(v, errp);
 320 out_obj:
 321     visit_end_struct(v, (void **)obj);
 322     if (!ok && visit_is_input(v)) {
 323         qapi_free_%(c_name)s(*obj);
 324         *obj = NULL;
 325     }
 326     return ok;
 327 }
 328 ''',
 329                  c_name=c_name(name))
 330
 331
 332 class QAPISchemaGenVisitVisitor(QAPISchemaModularCVisitor):
 333
 334     def __init__(self, prefix: str):
 335         super().__init__(
 336             prefix, 'qapi-visit', ' * Schema-defined QAPI visitors',
 337             ' * Built-in QAPI visitors', __doc__)
 338
 339     def _begin_builtin_module(self) -> None:
 340         self._genc.preamble_add(mcgen('''
 341 #include "qemu/osdep.h"
 342 #include "qapi/error.h"
 343 #include "qapi/qapi-builtin-visit.h"
 344 '''))
 345         self._genh.preamble_add(mcgen('''
 346 #include "qapi/visitor.h"
 347 #include "qapi/qapi-builtin-types.h"
 348
 349 '''))
 350
 351     def _begin_user_module(self, name: str) -> None:
 352         types = self._module_basename('qapi-types', name)
 353         visit = self._module_basename('qapi-visit', name)
 354         self._genc.preamble_add(mcgen('''
 355 #include "qemu/osdep.h"
 356 #include "qapi/error.h"
 357 #include "qapi/qmp/qerror.h"
 358 #include "%(visit)s.h"
 359 ''',
 360                                       visit=visit))
 361         self._genh.preamble_add(mcgen('''
 362 #include "qapi/qapi-builtin-visit.h"
 363 #include "%(types)s.h"
 364
 365 ''',
 366                                       types=types))
 367
 368     def visit_enum_type(self,
 369                         name: str,
 370                         info: Optional[QAPISourceInfo],
 371                         ifcond: QAPISchemaIfCond,
 372                         features: List[QAPISchemaFeature],
 373                         members: List[QAPISchemaEnumMember],
 374                         prefix: Optional[str]) -> None:
 375         with ifcontext(ifcond, self._genh, self._genc):
 376             self._genh.add(gen_visit_decl(name, scalar=True))
 377             self._genc.add(gen_visit_enum(name))
 378
 379     def visit_array_type(self,
 380                          name: str,
 381                          info: Optional[QAPISourceInfo],
 382                          ifcond: QAPISchemaIfCond,
 383                          element_type: QAPISchemaType) -> None:
 384         with ifcontext(ifcond, self._genh, self._genc):
 385             self._genh.add(gen_visit_decl(name))
 386             self._genc.add(gen_visit_list(name, element_type))
 387
 388     def visit_object_type(self,
 389                           name: str,
 390                           info: Optional[QAPISourceInfo],
 391                           ifcond: QAPISchemaIfCond,
 392                           features: List[QAPISchemaFeature],
 393                           base: Optional[QAPISchemaObjectType],
 394                           members: List[QAPISchemaObjectTypeMember],
 395                           variants: Optional[QAPISchemaVariants]) -> None:
 396         # Nothing to do for the special empty builtin
 397         if name == 'q_empty':
 398             return
 399         with ifcontext(ifcond, self._genh, self._genc):
 400             self._genh.add(gen_visit_members_decl(name))
 401             self._genc.add(gen_visit_object_members(name, base,
 402                                                     members, variants))
 403             # TODO Worth changing the visitor signature, so we could
 404             # directly use rather than repeat type.is_implicit()?
 405             if not name.startswith('q_'):
 406                 # only explicit types need an allocating visit
 407                 self._genh.add(gen_visit_decl(name))
 408                 self._genc.add(gen_visit_object(name))
 409
 410     def visit_alternate_type(self,
 411                              name: str,
 412                              info: Optional[QAPISourceInfo],
 413                              ifcond: QAPISchemaIfCond,
 414                              features: List[QAPISchemaFeature],
 415                              variants: QAPISchemaVariants) -> None:
 416         with ifcontext(ifcond, self._genh, self._genc):
 417             self._genh.add(gen_visit_decl(name))
 418             self._genc.add(gen_visit_alternate(name, variants))
 419
 420
 421 def gen_visit(schema: QAPISchema,
 422               output_dir: str,
 423               prefix: str,
 424               opt_builtins: bool) -> None:
 425     vis = QAPISchemaGenVisitVisitor(prefix)
 426     schema.visit(vis)
 427     vis.write(output_dir, opt_builtins)