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