Revision d195325b scripts/qapi-visit.py
| b/scripts/qapi-visit.py | ||
|---|---|---|
| 17 | 17 |
import getopt |
| 18 | 18 |
import errno |
| 19 | 19 |
|
| 20 |
def generate_visit_struct_body(field_prefix, members): |
|
| 21 |
ret = "" |
|
| 20 |
def generate_visit_struct_body(field_prefix, name, members): |
|
| 21 |
ret = mcgen('''
|
|
| 22 |
if (!error_is_set(errp)) {
|
|
| 23 |
''') |
|
| 24 |
push_indent() |
|
| 25 |
|
|
| 22 | 26 |
if len(field_prefix): |
| 23 | 27 |
field_prefix = field_prefix + "." |
| 28 |
ret += mcgen('''
|
|
| 29 |
Error **errp = &err; /* from outer scope */ |
|
| 30 |
Error *err = NULL; |
|
| 31 |
visit_start_struct(m, NULL, "", "%(name)s", 0, &err); |
|
| 32 |
''', |
|
| 33 |
name=name) |
|
| 34 |
else: |
|
| 35 |
ret += mcgen('''
|
|
| 36 |
Error *err = NULL; |
|
| 37 |
visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), &err); |
|
| 38 |
''', |
|
| 39 |
name=name) |
|
| 40 |
|
|
| 41 |
ret += mcgen('''
|
|
| 42 |
if (!err) {
|
|
| 43 |
if (!obj || *obj) {
|
|
| 44 |
''') |
|
| 45 |
|
|
| 46 |
push_indent() |
|
| 47 |
push_indent() |
|
| 24 | 48 |
for argname, argentry, optional, structured in parse_args(members): |
| 25 | 49 |
if optional: |
| 26 | 50 |
ret += mcgen('''
|
| 27 |
visit_start_optional(m, (obj && *obj) ? &(*obj)->%(c_prefix)shas_%(c_name)s : NULL, "%(name)s", errp);
|
|
| 28 |
if ((*obj)->%(prefix)shas_%(c_name)s) {
|
|
| 51 |
visit_start_optional(m, obj ? &(*obj)->%(c_prefix)shas_%(c_name)s : NULL, "%(name)s", &err);
|
|
| 52 |
if (obj && (*obj)->%(prefix)shas_%(c_name)s) {
|
|
| 29 | 53 |
''', |
| 30 | 54 |
c_prefix=c_var(field_prefix), prefix=field_prefix, |
| 31 | 55 |
c_name=c_var(argname), name=argname) |
| 32 | 56 |
push_indent() |
| 33 | 57 |
|
| 34 | 58 |
if structured: |
| 35 |
ret += mcgen('''
|
|
| 36 |
visit_start_struct(m, NULL, "", "%(name)s", 0, errp); |
|
| 37 |
''', |
|
| 38 |
name=argname) |
|
| 39 |
ret += generate_visit_struct_body(field_prefix + argname, argentry) |
|
| 40 |
ret += mcgen('''
|
|
| 41 |
visit_end_struct(m, errp); |
|
| 42 |
''') |
|
| 59 |
ret += generate_visit_struct_body(field_prefix + argname, argname, argentry) |
|
| 43 | 60 |
else: |
| 44 | 61 |
ret += mcgen('''
|
| 45 |
visit_type_%(type)s(m, (obj && *obj) ? &(*obj)->%(c_prefix)s%(c_name)s : NULL, "%(name)s", errp);
|
|
| 62 |
visit_type_%(type)s(m, obj ? &(*obj)->%(c_prefix)s%(c_name)s : NULL, "%(name)s", &err);
|
|
| 46 | 63 |
''', |
| 47 | 64 |
c_prefix=c_var(field_prefix), prefix=field_prefix, |
| 48 | 65 |
type=type_name(argentry), c_name=c_var(argname), |
| ... | ... | |
| 52 | 69 |
pop_indent() |
| 53 | 70 |
ret += mcgen('''
|
| 54 | 71 |
} |
| 55 |
visit_end_optional(m, errp); |
|
| 72 |
visit_end_optional(m, &err); |
|
| 73 |
''') |
|
| 74 |
|
|
| 75 |
pop_indent() |
|
| 76 |
ret += mcgen('''
|
|
| 77 |
|
|
| 78 |
error_propagate(errp, err); |
|
| 79 |
err = NULL; |
|
| 80 |
} |
|
| 81 |
''') |
|
| 82 |
|
|
| 83 |
pop_indent() |
|
| 84 |
pop_indent() |
|
| 85 |
ret += mcgen('''
|
|
| 86 |
/* Always call end_struct if start_struct succeeded. */ |
|
| 87 |
visit_end_struct(m, &err); |
|
| 88 |
} |
|
| 89 |
error_propagate(errp, err); |
|
| 90 |
} |
|
| 56 | 91 |
''') |
| 57 | 92 |
return ret |
| 58 | 93 |
|
| ... | ... | |
| 61 | 96 |
|
| 62 | 97 |
void visit_type_%(name)s(Visitor *m, %(name)s ** obj, const char *name, Error **errp) |
| 63 | 98 |
{
|
| 64 |
if (error_is_set(errp)) {
|
|
| 65 |
return; |
|
| 66 |
} |
|
| 67 |
visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), errp); |
|
| 68 |
if (obj && !*obj) {
|
|
| 69 |
goto end; |
|
| 70 |
} |
|
| 71 | 99 |
''', |
| 72 | 100 |
name=name) |
| 101 |
|
|
| 73 | 102 |
push_indent() |
| 74 |
ret += generate_visit_struct_body("", members)
|
|
| 103 |
ret += generate_visit_struct_body("", name, members)
|
|
| 75 | 104 |
pop_indent() |
| 76 | 105 |
|
| 77 | 106 |
ret += mcgen('''
|
| 78 |
end: |
|
| 79 |
visit_end_struct(m, errp); |
|
| 80 | 107 |
} |
| 81 | 108 |
''') |
| 82 | 109 |
return ret |
| ... | ... | |
| 87 | 114 |
void visit_type_%(name)sList(Visitor *m, %(name)sList ** obj, const char *name, Error **errp) |
| 88 | 115 |
{
|
| 89 | 116 |
GenericList *i, **prev = (GenericList **)obj; |
| 117 |
Error *err = NULL; |
|
| 90 | 118 |
|
| 91 |
if (error_is_set(errp)) {
|
|
| 92 |
return; |
|
| 93 |
} |
|
| 94 |
visit_start_list(m, name, errp); |
|
| 95 |
|
|
| 96 |
for (; (i = visit_next_list(m, prev, errp)) != NULL; prev = &i) {
|
|
| 97 |
%(name)sList *native_i = (%(name)sList *)i; |
|
| 98 |
visit_type_%(name)s(m, &native_i->value, NULL, errp); |
|
| 119 |
if (!error_is_set(errp)) {
|
|
| 120 |
visit_start_list(m, name, &err); |
|
| 121 |
if (!err) {
|
|
| 122 |
for (; (i = visit_next_list(m, prev, &err)) != NULL; prev = &i) {
|
|
| 123 |
%(name)sList *native_i = (%(name)sList *)i; |
|
| 124 |
visit_type_%(name)s(m, &native_i->value, NULL, &err); |
|
| 125 |
} |
|
| 126 |
error_propagate(errp, err); |
|
| 127 |
err = NULL; |
|
| 128 |
|
|
| 129 |
/* Always call end_list if start_list succeeded. */ |
|
| 130 |
visit_end_list(m, &err); |
|
| 131 |
} |
|
| 132 |
error_propagate(errp, err); |
|
| 99 | 133 |
} |
| 100 |
|
|
| 101 |
visit_end_list(m, errp); |
|
| 102 | 134 |
} |
| 103 | 135 |
''', |
| 104 | 136 |
name=name) |
| ... | ... | |
| 122 | 154 |
{
|
| 123 | 155 |
Error *err = NULL; |
| 124 | 156 |
|
| 125 |
if (error_is_set(errp)) {
|
|
| 126 |
return; |
|
| 127 |
} |
|
| 128 |
visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), &err); |
|
| 129 |
if (obj && !*obj) {
|
|
| 130 |
goto end; |
|
| 131 |
} |
|
| 132 |
visit_type_%(name)sKind(m, &(*obj)->kind, "type", &err); |
|
| 133 |
if (err) {
|
|
| 134 |
error_propagate(errp, err); |
|
| 135 |
goto end; |
|
| 136 |
} |
|
| 137 |
switch ((*obj)->kind) {
|
|
| 157 |
if (!error_is_set(errp)) {
|
|
| 158 |
visit_start_struct(m, (void **)obj, "%(name)s", name, sizeof(%(name)s), &err); |
|
| 159 |
if (!err) {
|
|
| 160 |
if (!obj || *obj) {
|
|
| 161 |
visit_type_%(name)sKind(m, &(*obj)->kind, "type", &err); |
|
| 162 |
if (!err) {
|
|
| 163 |
switch ((*obj)->kind) {
|
|
| 138 | 164 |
''', |
| 139 | 165 |
name=name) |
| 140 | 166 |
|
| 167 |
push_indent() |
|
| 168 |
push_indent() |
|
| 141 | 169 |
for key in members: |
| 142 | 170 |
ret += mcgen('''
|
| 143 |
case %(abbrev)s_KIND_%(enum)s: |
|
| 144 |
visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "data", errp);
|
|
| 145 |
break; |
|
| 171 |
case %(abbrev)s_KIND_%(enum)s:
|
|
| 172 |
visit_type_%(c_type)s(m, &(*obj)->%(c_name)s, "data", &err);
|
|
| 173 |
break;
|
|
| 146 | 174 |
''', |
| 147 | 175 |
abbrev = de_camel_case(name).upper(), |
| 148 | 176 |
enum = c_fun(de_camel_case(key)).upper(), |
| ... | ... | |
| 150 | 178 |
c_name=c_fun(key)) |
| 151 | 179 |
|
| 152 | 180 |
ret += mcgen('''
|
| 153 |
default: |
|
| 154 |
abort(); |
|
| 181 |
default: |
|
| 182 |
abort(); |
|
| 183 |
} |
|
| 184 |
} |
|
| 185 |
error_propagate(errp, err); |
|
| 186 |
err = NULL; |
|
| 187 |
} |
|
| 188 |
''') |
|
| 189 |
pop_indent() |
|
| 190 |
ret += mcgen('''
|
|
| 191 |
/* Always call end_struct if start_struct succeeded. */ |
|
| 192 |
visit_end_struct(m, &err); |
|
| 155 | 193 |
} |
| 156 |
end: |
|
| 157 |
visit_end_struct(m, errp); |
|
| 194 |
error_propagate(errp, err); |
|
| 195 |
} |
|
| 196 |
''') |
|
| 197 |
|
|
| 198 |
pop_indent(); |
|
| 199 |
ret += mcgen('''
|
|
| 158 | 200 |
} |
| 159 | 201 |
''') |
| 160 | 202 |
|
Also available in: Unified diff