scripts/qapi-event.py

   1 #
   2 # QAPI event generator
   3 #
   4 # Copyright (c) 2014 Wenchao Xia
   5 #
   6 # Authors:
   7 #  Wenchao Xia <wenchaoqemu@gmail.com>
   8 #
   9 # This work is licensed under the terms of the GNU GPL, version 2.
  10 # See the COPYING file in the top-level directory.
  11
  12 from ordereddict import OrderedDict
  13 from qapi import *
  14
  15 def _generate_event_api_name(event_name, params):
  16     api_name = "void qapi_event_send_%s(" % c_name(event_name).lower();
  17     l = len(api_name)
  18
  19     if params:
  20         for argname, argentry, optional in parse_args(params):
  21             if optional:
  22                 api_name += "bool has_%s,\n" % c_name(argname)
  23                 api_name += "".ljust(l)
  24
  25             api_name += "%s %s,\n" % (c_type(argentry, is_param=True),
  26                                       c_name(argname))
  27             api_name += "".ljust(l)
  28
  29     api_name += "Error **errp)"
  30     return api_name;
  31
  32
  33 # Following are the core functions that generate C APIs to emit event.
  34
  35 def generate_event_declaration(api_name):
  36     return mcgen('''
  37
  38 %(api_name)s;
  39 ''',
  40                  api_name = api_name)
  41
  42 def generate_event_implement(api_name, event_name, params):
  43     # step 1: declare any variables
  44     ret = mcgen("""
  45
  46 %(api_name)s
  47 {
  48     QDict *qmp;
  49     Error *local_err = NULL;
  50     QMPEventFuncEmit emit;
  51 """,
  52                 api_name = api_name)
  53
  54     if params:
  55         ret += mcgen("""
  56     QmpOutputVisitor *qov;
  57     Visitor *v;
  58     QObject *obj;
  59
  60 """)
  61
  62     # step 2: check emit function, create a dict
  63     ret += mcgen("""
  64     emit = qmp_event_get_func_emit();
  65     if (!emit) {
  66         return;
  67     }
  68
  69     qmp = qmp_event_build_dict("%(event_name)s");
  70
  71 """,
  72                  event_name = event_name)
  73
  74     # step 3: visit the params if params != None
  75     if params:
  76         ret += mcgen("""
  77     qov = qmp_output_visitor_new();
  78     g_assert(qov);
  79
  80     v = qmp_output_get_visitor(qov);
  81     g_assert(v);
  82
  83     /* Fake visit, as if all members are under a structure */
  84     visit_start_struct(v, NULL, "", "%(event_name)s", 0, &local_err);
  85     if (local_err) {
  86         goto clean;
  87     }
  88
  89 """,
  90                 event_name = event_name)
  91
  92         for argname, argentry, optional in parse_args(params):
  93             if optional:
  94                 ret += mcgen("""
  95     if (has_%(var)s) {
  96 """,
  97                              var = c_name(argname))
  98                 push_indent()
  99
 100             if argentry == "str":
 101                 var_type = "(char **)"
 102             else:
 103                 var_type = ""
 104
 105             ret += mcgen("""
 106     visit_type_%(type)s(v, %(var_type)s&%(var)s, "%(name)s", &local_err);
 107     if (local_err) {
 108         goto clean;
 109     }
 110 """,
 111                          var_type = var_type,
 112                          var = c_name(argname),
 113                          type = type_name(argentry),
 114                          name = argname)
 115
 116             if optional:
 117                 pop_indent()
 118                 ret += mcgen("""
 119     }
 120 """)
 121
 122         ret += mcgen("""
 123
 124     visit_end_struct(v, &local_err);
 125     if (local_err) {
 126         goto clean;
 127     }
 128
 129     obj = qmp_output_get_qobject(qov);
 130     g_assert(obj != NULL);
 131
 132     qdict_put_obj(qmp, "data", obj);
 133 """)
 134
 135     # step 4: call qmp event api
 136     ret += mcgen("""
 137     emit(%(event_enum_value)s, qmp, &local_err);
 138
 139 """,
 140                  event_enum_value = event_enum_value)
 141
 142     # step 5: clean up
 143     if params:
 144         ret += mcgen("""
 145  clean:
 146     qmp_output_visitor_cleanup(qov);
 147 """)
 148     ret += mcgen("""
 149     error_propagate(errp, local_err);
 150     QDECREF(qmp);
 151 }
 152 """)
 153
 154     return ret
 155
 156
 157 # Following are the functions that generate an enum type for all defined
 158 # events, similar to qapi-types.py. Here we already have enum name and
 159 # values which were generated before and recorded in event_enum_*. It also
 160 # works around the issue that "import qapi-types" can't work.
 161
 162 def generate_event_enum_decl(event_enum_name, event_enum_values):
 163     lookup_decl = mcgen('''
 164
 165 extern const char *%(event_enum_name)s_lookup[];
 166 ''',
 167                         event_enum_name = event_enum_name)
 168
 169     enum_decl = mcgen('''
 170 typedef enum %(event_enum_name)s {
 171 ''',
 172                       event_enum_name = event_enum_name)
 173
 174     # append automatically generated _MAX value
 175     enum_max_value = c_enum_const(event_enum_name, "MAX")
 176     enum_values = event_enum_values + [ enum_max_value ]
 177
 178     i = 0
 179     for value in enum_values:
 180         enum_decl += mcgen('''
 181     %(value)s = %(i)d,
 182 ''',
 183                      value = value,
 184                      i = i)
 185         i += 1
 186
 187     enum_decl += mcgen('''
 188 } %(event_enum_name)s;
 189 ''',
 190                        event_enum_name = event_enum_name)
 191
 192     return lookup_decl + enum_decl
 193
 194 def generate_event_enum_lookup(event_enum_name, event_enum_strings):
 195     ret = mcgen('''
 196
 197 const char *%(event_enum_name)s_lookup[] = {
 198 ''',
 199                 event_enum_name = event_enum_name)
 200
 201     for string in event_enum_strings:
 202         ret += mcgen('''
 203     "%(string)s",
 204 ''',
 205                      string = string)
 206
 207     ret += mcgen('''
 208     NULL,
 209 };
 210 ''')
 211     return ret
 212
 213 (input_file, output_dir, do_c, do_h, prefix, dummy) = parse_command_line()
 214
 215 c_comment = '''
 216 /*
 217  * schema-defined QAPI event functions
 218  *
 219  * Copyright (c) 2014 Wenchao Xia
 220  *
 221  * Authors:
 222  *  Wenchao Xia   <wenchaoqemu@gmail.com>
 223  *
 224  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 225  * See the COPYING.LIB file in the top-level directory.
 226  *
 227  */
 228 '''
 229 h_comment = '''
 230 /*
 231  * schema-defined QAPI event functions
 232  *
 233  * Copyright (c) 2014 Wenchao Xia
 234  *
 235  * Authors:
 236  *  Wenchao Xia  <wenchaoqemu@gmail.com>
 237  *
 238  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 239  * See the COPYING.LIB file in the top-level directory.
 240  *
 241  */
 242 '''
 243
 244 (fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
 245                             'qapi-event.c', 'qapi-event.h',
 246                             c_comment, h_comment)
 247
 248 fdef.write(mcgen('''
 249 #include "qemu-common.h"
 250 #include "%(prefix)sqapi-event.h"
 251 #include "%(prefix)sqapi-visit.h"
 252 #include "qapi/qmp-output-visitor.h"
 253 #include "qapi/qmp-event.h"
 254
 255 ''',
 256                  prefix=prefix))
 257
 258 fdecl.write(mcgen('''
 259 #include "qapi/error.h"
 260 #include "qapi/qmp/qdict.h"
 261 #include "%(prefix)sqapi-types.h"
 262
 263 ''',
 264                   prefix=prefix))
 265
 266 exprs = parse_schema(input_file)
 267
 268 event_enum_name = c_name(prefix + "QAPIEvent", protect=False)
 269 event_enum_values = []
 270 event_enum_strings = []
 271
 272 for expr in exprs:
 273     if expr.has_key('event'):
 274         event_name = expr['event']
 275         params = expr.get('data')
 276         if params and len(params) == 0:
 277             params = None
 278
 279         api_name = _generate_event_api_name(event_name, params)
 280         ret = generate_event_declaration(api_name)
 281         fdecl.write(ret)
 282
 283         # We need an enum value per event
 284         event_enum_value = c_enum_const(event_enum_name, event_name)
 285         ret = generate_event_implement(api_name, event_name, params)
 286         fdef.write(ret)
 287
 288         # Record it, and generate enum later
 289         event_enum_values.append(event_enum_value)
 290         event_enum_strings.append(event_name)
 291
 292 ret = generate_event_enum_decl(event_enum_name, event_enum_values)
 293 fdecl.write(ret)
 294 ret = generate_event_enum_lookup(event_enum_name, event_enum_strings)
 295 fdef.write(ret)
 296
 297 close_output(fdef, fdecl)