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