Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 1 | # |
| 2 | # QAPI visitor generator |
| 3 | # |
| 4 | # Copyright IBM, Corp. 2011 |
Eric Blake | 92b09ba | 2016-01-29 06:48:47 -0700 | [diff] [blame] | 5 | # Copyright (C) 2014-2016 Red Hat, Inc. |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 6 | # |
| 7 | # Authors: |
| 8 | # Anthony Liguori <aliguori@us.ibm.com> |
| 9 | # Michael Roth <mdroth@linux.vnet.ibm.com> |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 10 | # Markus Armbruster <armbru@redhat.com> |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 11 | # |
Markus Armbruster | 678e48a | 2014-03-01 08:40:34 +0100 | [diff] [blame] | 12 | # This work is licensed under the terms of the GNU GPL, version 2. |
| 13 | # See the COPYING file in the top-level directory. |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 14 | |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 15 | from qapi import * |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 16 | |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 17 | |
Markus Armbruster | 60f8546 | 2015-09-16 13:06:17 +0200 | [diff] [blame] | 18 | def gen_visit_decl(name, scalar=False): |
| 19 | c_type = c_name(name) + ' *' |
| 20 | if not scalar: |
| 21 | c_type += '*' |
| 22 | return mcgen(''' |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 23 | void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_type)sobj, Error **errp); |
Markus Armbruster | 60f8546 | 2015-09-16 13:06:17 +0200 | [diff] [blame] | 24 | ''', |
| 25 | c_name=c_name(name), c_type=c_type) |
| 26 | |
| 27 | |
Eric Blake | 4d91e91 | 2016-03-03 09:16:45 -0700 | [diff] [blame] | 28 | def gen_visit_members_decl(name): |
Eric Blake | 2208d64 | 2016-02-17 23:48:25 -0700 | [diff] [blame] | 29 | return mcgen(''' |
Markus Armbruster | 8c3f8e7 | 2015-06-26 10:19:11 +0200 | [diff] [blame] | 30 | |
Eric Blake | 4d91e91 | 2016-03-03 09:16:45 -0700 | [diff] [blame] | 31 | void visit_type_%(c_name)s_members(Visitor *v, %(c_name)s *obj, Error **errp); |
Markus Armbruster | 8c3f8e7 | 2015-06-26 10:19:11 +0200 | [diff] [blame] | 32 | ''', |
Eric Blake | 4d91e91 | 2016-03-03 09:16:45 -0700 | [diff] [blame] | 33 | c_name=c_name(name)) |
Eric Blake | d02cf37 | 2015-10-26 16:34:46 -0600 | [diff] [blame] | 34 | |
| 35 | |
Eric Blake | 14f00c6 | 2016-03-03 09:16:43 -0700 | [diff] [blame] | 36 | def gen_visit_object_members(name, base, members, variants): |
Eric Blake | 4d91e91 | 2016-03-03 09:16:45 -0700 | [diff] [blame] | 37 | ret = mcgen(''' |
Kevin Wolf | 50f2bdc | 2013-07-03 15:58:57 +0200 | [diff] [blame] | 38 | |
Eric Blake | 4d91e91 | 2016-03-03 09:16:45 -0700 | [diff] [blame] | 39 | void visit_type_%(c_name)s_members(Visitor *v, %(c_name)s *obj, Error **errp) |
Kevin Wolf | 50f2bdc | 2013-07-03 15:58:57 +0200 | [diff] [blame] | 40 | { |
| 41 | Error *err = NULL; |
Markus Armbruster | 3a864e7 | 2015-07-01 16:55:15 +0200 | [diff] [blame] | 42 | |
Kevin Wolf | 50f2bdc | 2013-07-03 15:58:57 +0200 | [diff] [blame] | 43 | ''', |
Eric Blake | 4d91e91 | 2016-03-03 09:16:45 -0700 | [diff] [blame] | 44 | c_name=c_name(name)) |
Paolo Bonzini | d195325 | 2012-07-17 16:17:04 +0200 | [diff] [blame] | 45 | |
Kevin Wolf | 622f557 | 2013-09-19 11:56:36 +0200 | [diff] [blame] | 46 | if base: |
| 47 | ret += mcgen(''' |
Eric Blake | c81200b | 2016-03-03 09:16:44 -0700 | [diff] [blame] | 48 | visit_type_%(c_type)s_members(v, (%(c_type)s *)obj, &err); |
Eric Blake | fa274ed | 2016-07-13 21:50:17 -0600 | [diff] [blame] | 49 | if (err) { |
| 50 | goto out; |
| 51 | } |
Kevin Wolf | 622f557 | 2013-09-19 11:56:36 +0200 | [diff] [blame] | 52 | ''', |
Eric Blake | ddf2190 | 2015-10-26 16:34:49 -0600 | [diff] [blame] | 53 | c_type=base.c_name()) |
Kevin Wolf | 622f557 | 2013-09-19 11:56:36 +0200 | [diff] [blame] | 54 | |
Eric Blake | 12f254f | 2016-03-17 16:48:35 -0600 | [diff] [blame] | 55 | for memb in members: |
| 56 | if memb.optional: |
| 57 | ret += mcgen(''' |
| 58 | if (visit_optional(v, "%(name)s", &obj->has_%(c_name)s)) { |
| 59 | ''', |
| 60 | name=memb.name, c_name=c_name(memb.name)) |
| 61 | push_indent() |
| 62 | ret += mcgen(''' |
| 63 | visit_type_%(c_type)s(v, "%(name)s", &obj->%(c_name)s, &err); |
Eric Blake | fa274ed | 2016-07-13 21:50:17 -0600 | [diff] [blame] | 64 | if (err) { |
| 65 | goto out; |
| 66 | } |
Eric Blake | 12f254f | 2016-03-17 16:48:35 -0600 | [diff] [blame] | 67 | ''', |
| 68 | c_type=memb.type.c_name(), name=memb.name, |
| 69 | c_name=c_name(memb.name)) |
Eric Blake | 12f254f | 2016-03-17 16:48:35 -0600 | [diff] [blame] | 70 | if memb.optional: |
| 71 | pop_indent() |
| 72 | ret += mcgen(''' |
| 73 | } |
| 74 | ''') |
Paolo Bonzini | d195325 | 2012-07-17 16:17:04 +0200 | [diff] [blame] | 75 | |
Eric Blake | 9a5cd42 | 2016-02-17 23:48:20 -0700 | [diff] [blame] | 76 | if variants: |
| 77 | ret += mcgen(''' |
Eric Blake | 6555190 | 2016-02-17 23:48:22 -0700 | [diff] [blame] | 78 | switch (obj->%(c_name)s) { |
Eric Blake | 9a5cd42 | 2016-02-17 23:48:20 -0700 | [diff] [blame] | 79 | ''', |
| 80 | c_name=c_name(variants.tag_member.name)) |
| 81 | |
| 82 | for var in variants.variants: |
Eric Blake | 9a5cd42 | 2016-02-17 23:48:20 -0700 | [diff] [blame] | 83 | ret += mcgen(''' |
| 84 | case %(case)s: |
Eric Blake | 32bafa8 | 2016-03-17 16:48:37 -0600 | [diff] [blame] | 85 | visit_type_%(c_type)s_members(v, &obj->u.%(c_name)s, &err); |
| 86 | break; |
Eric Blake | 9a5cd42 | 2016-02-17 23:48:20 -0700 | [diff] [blame] | 87 | ''', |
| 88 | case=c_enum_const(variants.tag_member.type.name, |
| 89 | var.name, |
Eric Blake | 32bafa8 | 2016-03-17 16:48:37 -0600 | [diff] [blame] | 90 | variants.tag_member.type.prefix), |
| 91 | c_type=var.type.c_name(), c_name=c_name(var.name)) |
Eric Blake | 9a5cd42 | 2016-02-17 23:48:20 -0700 | [diff] [blame] | 92 | |
| 93 | ret += mcgen(''' |
| 94 | default: |
| 95 | abort(); |
| 96 | } |
| 97 | ''') |
| 98 | |
Eric Blake | 12f254f | 2016-03-17 16:48:35 -0600 | [diff] [blame] | 99 | # 'goto out' produced for base, for each member, and if variants were |
| 100 | # present |
Eric Blake | 9a5cd42 | 2016-02-17 23:48:20 -0700 | [diff] [blame] | 101 | if base or members or variants: |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 102 | ret += mcgen(''' |
Kevin Wolf | 50f2bdc | 2013-07-03 15:58:57 +0200 | [diff] [blame] | 103 | |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 104 | out: |
| 105 | ''') |
| 106 | ret += mcgen(''' |
Kevin Wolf | 50f2bdc | 2013-07-03 15:58:57 +0200 | [diff] [blame] | 107 | error_propagate(errp, err); |
| 108 | } |
| 109 | ''') |
Kevin Wolf | d131c89 | 2013-07-02 16:18:35 +0200 | [diff] [blame] | 110 | return ret |
| 111 | |
| 112 | |
Markus Armbruster | 441cbac | 2015-09-16 13:06:10 +0200 | [diff] [blame] | 113 | def gen_visit_list(name, element_type): |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 114 | return mcgen(''' |
| 115 | |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 116 | void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp) |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 117 | { |
Paolo Bonzini | d195325 | 2012-07-17 16:17:04 +0200 | [diff] [blame] | 118 | Error *err = NULL; |
Eric Blake | d9f62dd | 2016-04-28 15:45:31 -0600 | [diff] [blame] | 119 | %(c_name)s *tail; |
| 120 | size_t size = sizeof(**obj); |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 121 | |
Eric Blake | d9f62dd | 2016-04-28 15:45:31 -0600 | [diff] [blame] | 122 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 123 | if (err) { |
| 124 | goto out; |
Paolo Bonzini | b6f0474 | 2012-03-22 12:51:06 +0100 | [diff] [blame] | 125 | } |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 126 | |
Eric Blake | d9f62dd | 2016-04-28 15:45:31 -0600 | [diff] [blame] | 127 | for (tail = *obj; tail; |
| 128 | tail = (%(c_name)s *)visit_next_list(v, (GenericList *)tail, size)) { |
| 129 | visit_type_%(c_elt_type)s(v, NULL, &tail->value, &err); |
| 130 | if (err) { |
| 131 | break; |
| 132 | } |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 133 | } |
| 134 | |
Markus Armbruster | a4a1c70 | 2017-03-03 13:32:45 +0100 | [diff] [blame] | 135 | if (!err) { |
| 136 | visit_check_list(v, &err); |
| 137 | } |
Eric Blake | 1158bb2 | 2016-06-09 10:48:34 -0600 | [diff] [blame] | 138 | visit_end_list(v, (void **)obj); |
Eric Blake | 68ab47e | 2016-04-28 15:45:32 -0600 | [diff] [blame] | 139 | if (err && visit_is_input(v)) { |
| 140 | qapi_free_%(c_name)s(*obj); |
| 141 | *obj = NULL; |
| 142 | } |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 143 | out: |
| 144 | error_propagate(errp, err); |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 145 | } |
| 146 | ''', |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 147 | c_name=c_name(name), c_elt_type=element_type.c_name()) |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 148 | |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 149 | |
| 150 | def gen_visit_enum(name): |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 151 | return mcgen(''' |
| 152 | |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 153 | void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s *obj, Error **errp) |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 154 | { |
Eric Blake | 395a233 | 2016-01-29 06:48:52 -0700 | [diff] [blame] | 155 | int value = *obj; |
Eric Blake | 337283d | 2016-01-29 06:48:57 -0700 | [diff] [blame] | 156 | visit_type_enum(v, name, &value, %(c_name)s_lookup, errp); |
Eric Blake | 395a233 | 2016-01-29 06:48:52 -0700 | [diff] [blame] | 157 | *obj = value; |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 158 | } |
| 159 | ''', |
Eric Blake | 337283d | 2016-01-29 06:48:57 -0700 | [diff] [blame] | 160 | c_name=c_name(name)) |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 161 | |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 162 | |
Markus Armbruster | 441cbac | 2015-09-16 13:06:10 +0200 | [diff] [blame] | 163 | def gen_visit_alternate(name, variants): |
Eric Blake | d00341a | 2015-12-01 22:20:51 -0700 | [diff] [blame] | 164 | promote_int = 'true' |
Eric Blake | becceed | 2016-02-17 23:48:26 -0700 | [diff] [blame] | 165 | ret = '' |
Eric Blake | d00341a | 2015-12-01 22:20:51 -0700 | [diff] [blame] | 166 | for var in variants.variants: |
Marc-André Lureau | 01b2ffc | 2017-06-07 20:35:58 +0400 | [diff] [blame^] | 167 | if var.type.alternate_qtype() == 'QTYPE_QNUM': |
Eric Blake | d00341a | 2015-12-01 22:20:51 -0700 | [diff] [blame] | 168 | promote_int = 'false' |
| 169 | |
Eric Blake | becceed | 2016-02-17 23:48:26 -0700 | [diff] [blame] | 170 | ret += mcgen(''' |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 171 | |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 172 | void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp) |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 173 | { |
| 174 | Error *err = NULL; |
| 175 | |
Eric Blake | dbf1192 | 2016-02-17 23:48:29 -0700 | [diff] [blame] | 176 | visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj), |
| 177 | %(promote_int)s, &err); |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 178 | if (err) { |
| 179 | goto out; |
| 180 | } |
Eric Blake | 9b4e38f | 2016-06-15 11:37:51 -0600 | [diff] [blame] | 181 | if (!*obj) { |
| 182 | goto out_obj; |
| 183 | } |
Eric Blake | 150d056 | 2015-10-26 16:34:52 -0600 | [diff] [blame] | 184 | switch ((*obj)->type) { |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 185 | ''', |
Eric Blake | becceed | 2016-02-17 23:48:26 -0700 | [diff] [blame] | 186 | c_name=c_name(name), promote_int=promote_int) |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 187 | |
Markus Armbruster | 441cbac | 2015-09-16 13:06:10 +0200 | [diff] [blame] | 188 | for var in variants.variants: |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 189 | ret += mcgen(''' |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 190 | case %(case)s: |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 191 | ''', |
Eric Blake | becceed | 2016-02-17 23:48:26 -0700 | [diff] [blame] | 192 | case=var.type.alternate_qtype()) |
| 193 | if isinstance(var.type, QAPISchemaObjectType): |
| 194 | ret += mcgen(''' |
| 195 | visit_start_struct(v, name, NULL, 0, &err); |
| 196 | if (err) { |
| 197 | break; |
| 198 | } |
Eric Blake | c81200b | 2016-03-03 09:16:44 -0700 | [diff] [blame] | 199 | visit_type_%(c_type)s_members(v, &(*obj)->u.%(c_name)s, &err); |
Eric Blake | 15c2f66 | 2016-04-28 15:45:27 -0600 | [diff] [blame] | 200 | if (!err) { |
| 201 | visit_check_struct(v, &err); |
| 202 | } |
Eric Blake | 1158bb2 | 2016-06-09 10:48:34 -0600 | [diff] [blame] | 203 | visit_end_struct(v, NULL); |
Eric Blake | becceed | 2016-02-17 23:48:26 -0700 | [diff] [blame] | 204 | ''', |
| 205 | c_type=var.type.c_name(), |
| 206 | c_name=c_name(var.name)) |
| 207 | else: |
| 208 | ret += mcgen(''' |
| 209 | visit_type_%(c_type)s(v, name, &(*obj)->u.%(c_name)s, &err); |
| 210 | ''', |
| 211 | c_type=var.type.c_name(), |
| 212 | c_name=c_name(var.name)) |
| 213 | ret += mcgen(''' |
| 214 | break; |
| 215 | ''') |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 216 | |
| 217 | ret += mcgen(''' |
Eric Blake | 9b4e38f | 2016-06-15 11:37:51 -0600 | [diff] [blame] | 218 | case QTYPE_NONE: |
| 219 | abort(); |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 220 | default: |
Eric Blake | 0426d53 | 2015-12-01 22:20:48 -0700 | [diff] [blame] | 221 | error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null", |
| 222 | "%(name)s"); |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 223 | } |
Eric Blake | 9b4e38f | 2016-06-15 11:37:51 -0600 | [diff] [blame] | 224 | out_obj: |
Eric Blake | 1158bb2 | 2016-06-09 10:48:34 -0600 | [diff] [blame] | 225 | visit_end_alternate(v, (void **)obj); |
Eric Blake | 68ab47e | 2016-04-28 15:45:32 -0600 | [diff] [blame] | 226 | if (err && visit_is_input(v)) { |
| 227 | qapi_free_%(c_name)s(*obj); |
| 228 | *obj = NULL; |
| 229 | } |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 230 | out: |
| 231 | error_propagate(errp, err); |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 232 | } |
Eric Blake | 0426d53 | 2015-12-01 22:20:48 -0700 | [diff] [blame] | 233 | ''', |
Eric Blake | 68ab47e | 2016-04-28 15:45:32 -0600 | [diff] [blame] | 234 | name=name, c_name=c_name(name)) |
Kevin Wolf | 69dd62d | 2013-07-08 16:14:21 +0200 | [diff] [blame] | 235 | |
| 236 | return ret |
| 237 | |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 238 | |
Markus Armbruster | 59d9e84 | 2016-02-17 23:48:21 -0700 | [diff] [blame] | 239 | def gen_visit_object(name, base, members, variants): |
Eric Blake | 7ce106a | 2016-03-17 16:48:30 -0600 | [diff] [blame] | 240 | return mcgen(''' |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 241 | |
Eric Blake | 51e72bc | 2016-01-29 06:48:54 -0700 | [diff] [blame] | 242 | void visit_type_%(c_name)s(Visitor *v, const char *name, %(c_name)s **obj, Error **errp) |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 243 | { |
Paolo Bonzini | dc8fb6d | 2012-03-06 18:55:56 +0100 | [diff] [blame] | 244 | Error *err = NULL; |
| 245 | |
Eric Blake | 337283d | 2016-01-29 06:48:57 -0700 | [diff] [blame] | 246 | visit_start_struct(v, name, (void **)obj, sizeof(%(c_name)s), &err); |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 247 | if (err) { |
| 248 | goto out; |
| 249 | } |
Eric Blake | e36c714 | 2015-09-29 16:21:11 -0600 | [diff] [blame] | 250 | if (!*obj) { |
| 251 | goto out_obj; |
| 252 | } |
Eric Blake | c81200b | 2016-03-03 09:16:44 -0700 | [diff] [blame] | 253 | visit_type_%(c_name)s_members(v, *obj, &err); |
Eric Blake | 15c2f66 | 2016-04-28 15:45:27 -0600 | [diff] [blame] | 254 | if (err) { |
| 255 | goto out_obj; |
| 256 | } |
| 257 | visit_check_struct(v, &err); |
Eric Blake | 9a5cd42 | 2016-02-17 23:48:20 -0700 | [diff] [blame] | 258 | out_obj: |
Eric Blake | 1158bb2 | 2016-06-09 10:48:34 -0600 | [diff] [blame] | 259 | visit_end_struct(v, (void **)obj); |
Eric Blake | 68ab47e | 2016-04-28 15:45:32 -0600 | [diff] [blame] | 260 | if (err && visit_is_input(v)) { |
| 261 | qapi_free_%(c_name)s(*obj); |
| 262 | *obj = NULL; |
| 263 | } |
Markus Armbruster | 297a364 | 2014-05-07 09:53:54 +0200 | [diff] [blame] | 264 | out: |
| 265 | error_propagate(errp, err); |
Paolo Bonzini | dc8fb6d | 2012-03-06 18:55:56 +0100 | [diff] [blame] | 266 | } |
Eric Blake | 9a5cd42 | 2016-02-17 23:48:20 -0700 | [diff] [blame] | 267 | ''', |
| 268 | c_name=c_name(name)) |
Paolo Bonzini | dc8fb6d | 2012-03-06 18:55:56 +0100 | [diff] [blame] | 269 | |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 270 | |
Markus Armbruster | 441cbac | 2015-09-16 13:06:10 +0200 | [diff] [blame] | 271 | class QAPISchemaGenVisitVisitor(QAPISchemaVisitor): |
| 272 | def __init__(self): |
| 273 | self.decl = None |
| 274 | self.defn = None |
| 275 | self._btin = None |
| 276 | |
| 277 | def visit_begin(self, schema): |
| 278 | self.decl = '' |
| 279 | self.defn = '' |
| 280 | self._btin = guardstart('QAPI_VISIT_BUILTIN') |
| 281 | |
| 282 | def visit_end(self): |
| 283 | # To avoid header dependency hell, we always generate |
| 284 | # declarations for built-in types in our header files and |
| 285 | # simply guard them. See also do_builtins (command line |
| 286 | # option -b). |
| 287 | self._btin += guardend('QAPI_VISIT_BUILTIN') |
| 288 | self.decl = self._btin + self.decl |
| 289 | self._btin = None |
| 290 | |
| 291 | def visit_enum_type(self, name, info, values, prefix): |
Eric Blake | 7264f5c | 2015-12-01 22:20:47 -0700 | [diff] [blame] | 292 | # Special case for our lone builtin enum type |
| 293 | # TODO use something cleaner than existence of info |
| 294 | if not info: |
| 295 | self._btin += gen_visit_decl(name, scalar=True) |
| 296 | if do_builtins: |
| 297 | self.defn += gen_visit_enum(name) |
| 298 | else: |
| 299 | self.decl += gen_visit_decl(name, scalar=True) |
| 300 | self.defn += gen_visit_enum(name) |
Markus Armbruster | 441cbac | 2015-09-16 13:06:10 +0200 | [diff] [blame] | 301 | |
| 302 | def visit_array_type(self, name, info, element_type): |
| 303 | decl = gen_visit_decl(name) |
| 304 | defn = gen_visit_list(name, element_type) |
| 305 | if isinstance(element_type, QAPISchemaBuiltinType): |
| 306 | self._btin += decl |
| 307 | if do_builtins: |
| 308 | self.defn += defn |
| 309 | else: |
| 310 | self.decl += decl |
| 311 | self.defn += defn |
| 312 | |
| 313 | def visit_object_type(self, name, info, base, members, variants): |
Eric Blake | 7ce106a | 2016-03-17 16:48:30 -0600 | [diff] [blame] | 314 | # Nothing to do for the special empty builtin |
| 315 | if name == 'q_empty': |
| 316 | return |
Eric Blake | 4d91e91 | 2016-03-03 09:16:45 -0700 | [diff] [blame] | 317 | self.decl += gen_visit_members_decl(name) |
Eric Blake | 7ce106a | 2016-03-17 16:48:30 -0600 | [diff] [blame] | 318 | self.defn += gen_visit_object_members(name, base, members, variants) |
| 319 | # TODO Worth changing the visitor signature, so we could |
| 320 | # directly use rather than repeat type.is_implicit()? |
| 321 | if not name.startswith('q_'): |
| 322 | # only explicit types need an allocating visit |
| 323 | self.decl += gen_visit_decl(name) |
| 324 | self.defn += gen_visit_object(name, base, members, variants) |
Markus Armbruster | 441cbac | 2015-09-16 13:06:10 +0200 | [diff] [blame] | 325 | |
| 326 | def visit_alternate_type(self, name, info, variants): |
| 327 | self.decl += gen_visit_decl(name) |
| 328 | self.defn += gen_visit_alternate(name, variants) |
| 329 | |
| 330 | # If you link code generated from multiple schemata, you want only one |
| 331 | # instance of the code for built-in types. Generate it only when |
| 332 | # do_builtins, enabled by command line option -b. See also |
| 333 | # QAPISchemaGenVisitVisitor.visit_end(). |
Michael Roth | 7c946bc | 2013-05-10 17:46:02 -0500 | [diff] [blame] | 334 | do_builtins = False |
Avi Kivity | 8d3bc51 | 2011-12-27 16:02:16 +0200 | [diff] [blame] | 335 | |
Markus Armbruster | 2114f5a | 2015-04-02 13:12:21 +0200 | [diff] [blame] | 336 | (input_file, output_dir, do_c, do_h, prefix, opts) = \ |
Markus Armbruster | ef801a9 | 2017-03-15 13:57:08 +0100 | [diff] [blame] | 337 | parse_command_line('b', ['builtins']) |
Avi Kivity | 8d3bc51 | 2011-12-27 16:02:16 +0200 | [diff] [blame] | 338 | |
Markus Armbruster | 2114f5a | 2015-04-02 13:12:21 +0200 | [diff] [blame] | 339 | for o, a in opts: |
Markus Armbruster | ef801a9 | 2017-03-15 13:57:08 +0100 | [diff] [blame] | 340 | if o in ('-b', '--builtins'): |
Markus Armbruster | 2114f5a | 2015-04-02 13:12:21 +0200 | [diff] [blame] | 341 | do_builtins = True |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 342 | |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 343 | c_comment = ''' |
| 344 | /* |
| 345 | * schema-defined QAPI visitor functions |
| 346 | * |
| 347 | * Copyright IBM, Corp. 2011 |
| 348 | * |
| 349 | * Authors: |
| 350 | * Anthony Liguori <aliguori@us.ibm.com> |
| 351 | * |
| 352 | * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. |
| 353 | * See the COPYING.LIB file in the top-level directory. |
| 354 | * |
| 355 | */ |
| 356 | ''' |
| 357 | h_comment = ''' |
| 358 | /* |
| 359 | * schema-defined QAPI visitor functions |
| 360 | * |
| 361 | * Copyright IBM, Corp. 2011 |
| 362 | * |
| 363 | * Authors: |
| 364 | * Anthony Liguori <aliguori@us.ibm.com> |
| 365 | * |
| 366 | * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. |
| 367 | * See the COPYING.LIB file in the top-level directory. |
| 368 | * |
| 369 | */ |
| 370 | ''' |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 371 | |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 372 | (fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix, |
| 373 | 'qapi-visit.c', 'qapi-visit.h', |
| 374 | c_comment, h_comment) |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 375 | |
| 376 | fdef.write(mcgen(''' |
Eric Blake | 9167ebd | 2016-02-08 08:36:46 -0700 | [diff] [blame] | 377 | #include "qemu/osdep.h" |
Paolo Bonzini | 79ee7df | 2012-12-06 11:22:34 +0100 | [diff] [blame] | 378 | #include "qemu-common.h" |
Markus Armbruster | da34e65 | 2016-03-14 09:01:28 +0100 | [diff] [blame] | 379 | #include "qapi/error.h" |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 380 | #include "%(prefix)sqapi-visit.h" |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 381 | ''', |
Markus Armbruster | e98859a | 2015-09-16 13:06:16 +0200 | [diff] [blame] | 382 | prefix=prefix)) |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 383 | |
| 384 | fdecl.write(mcgen(''' |
Paolo Bonzini | 7b1b5d1 | 2012-12-17 18:19:43 +0100 | [diff] [blame] | 385 | #include "qapi/visitor.h" |
Eric Blake | 0426d53 | 2015-12-01 22:20:48 -0700 | [diff] [blame] | 386 | #include "qapi/qmp/qerror.h" |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 387 | #include "%(prefix)sqapi-types.h" |
Michael Roth | 7c946bc | 2013-05-10 17:46:02 -0500 | [diff] [blame] | 388 | |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 389 | ''', |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 390 | prefix=prefix)) |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 391 | |
Markus Armbruster | 441cbac | 2015-09-16 13:06:10 +0200 | [diff] [blame] | 392 | schema = QAPISchema(input_file) |
| 393 | gen = QAPISchemaGenVisitVisitor() |
| 394 | schema.visit(gen) |
| 395 | fdef.write(gen.defn) |
| 396 | fdecl.write(gen.decl) |
Michael Roth | 06d64c6 | 2011-07-19 14:50:41 -0500 | [diff] [blame] | 397 | |
Markus Armbruster | 12f8e1b | 2015-04-02 14:46:39 +0200 | [diff] [blame] | 398 | close_output(fdef, fdecl) |