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 import sys
  15 import os
  16 import getopt
  17 import errno
  18
  19 def _generate_event_api_name(event_name, params):
  20     api_name = "void qapi_event_send_%s(" % c_name(event_name).lower();
  21     l = len(api_name)
  22
  23     if params:
  24         for argname, argentry, optional in parse_args(params):
  25             if optional:
  26                 api_name += "bool has_%s,\n" % c_name(argname)
  27                 api_name += "".ljust(l)
  28
  29             api_name += "%s %s,\n" % (c_type(argentry, is_param=True),
  30                                       c_name(argname))
  31             api_name += "".ljust(l)
  32
  33     api_name += "Error **errp)"
  34     return api_name;
  35
  36
  37 # Following are the core functions that generate C APIs to emit event.
  38
  39 def generate_event_declaration(api_name):
  40     return mcgen('''
  41
  42 %(api_name)s;
  43 ''',
  44                  api_name = api_name)
  45
  46 def generate_event_implement(api_name, event_name, params):
  47     # step 1: declare any variables
  48     ret = mcgen("""
  49
  50 %(api_name)s
  51 {
  52     QDict *qmp;
  53     Error *local_err = NULL;
  54     QMPEventFuncEmit emit;
  55 """,
  56                 api_name = api_name)
  57
  58     if params:
  59         ret += mcgen("""
  60     QmpOutputVisitor *qov;
  61     Visitor *v;
  62     QObject *obj;
  63
  64 """)
  65
  66     # step 2: check emit function, create a dict
  67     ret += mcgen("""
  68     emit = qmp_event_get_func_emit();
  69     if (!emit) {
  70         return;
  71     }
  72
  73     qmp = qmp_event_build_dict("%(event_name)s");
  74
  75 """,
  76                  event_name = event_name)
  77
  78     # step 3: visit the params if params != None
  79     if params:
  80         ret += mcgen("""
  81     qov = qmp_output_visitor_new();
  82     g_assert(qov);
  83
  84     v = qmp_output_get_visitor(qov);
  85     g_assert(v);
  86
  87     /* Fake visit, as if all members are under a structure */
  88     visit_start_struct(v, NULL, "", "%(event_name)s", 0, &local_err);
  89     if (local_err) {
  90         goto clean;
  91     }
  92
  93 """,
  94                 event_name = event_name)
  95
  96         for argname, argentry, optional in parse_args(params):
  97             if optional:
  98                 ret += mcgen("""
  99     if (has_%(var)s) {
 100 """,
 101                              var = c_name(argname))
 102                 push_indent()
 103
 104             if argentry == "str":
 105                 var_type = "(char **)"
 106             else:
 107                 var_type = ""
 108
 109             ret += mcgen("""
 110     visit_type_%(type)s(v, %(var_type)s&%(var)s, "%(name)s", &local_err);
 111     if (local_err) {
 112         goto clean;
 113     }
 114 """,
 115                          var_type = var_type,
 116                          var = c_name(argname),
 117                          type = type_name(argentry),
 118                          name = argname)
 119
 120             if optional:
 121                 pop_indent()
 122                 ret += mcgen("""
 123     }
 124 """)
 125
 126         ret += mcgen("""
 127
 128     visit_end_struct(v, &local_err);
 129     if (local_err) {
 130         goto clean;
 131     }
 132
 133     obj = qmp_output_get_qobject(qov);
 134     g_assert(obj != NULL);
 135
 136     qdict_put_obj(qmp, "data", obj);
 137 """)
 138
 139     # step 4: call qmp event api
 140     ret += mcgen("""
 141     emit(%(event_enum_value)s, qmp, &local_err);
 142
 143 """,
 144                  event_enum_value = event_enum_value)
 145
 146     # step 5: clean up
 147     if params:
 148         ret += mcgen("""
 149  clean:
 150     qmp_output_visitor_cleanup(qov);
 151 """)
 152     ret += mcgen("""
 153     error_propagate(errp, local_err);
 154     QDECREF(qmp);
 155 }
 156 """)
 157
 158     return ret
 159
 160
 161 # Following are the functions that generate an enum type for all defined
 162 # events, similar to qapi-types.py. Here we already have enum name and
 163 # values which were generated before and recorded in event_enum_*. It also
 164 # works around the issue that "import qapi-types" can't work.
 165
 166 def generate_event_enum_decl(event_enum_name, event_enum_values):
 167     lookup_decl = mcgen('''
 168
 169 extern const char *%(event_enum_name)s_lookup[];
 170 ''',
 171                         event_enum_name = event_enum_name)
 172
 173     enum_decl = mcgen('''
 174 typedef enum %(event_enum_name)s
 175 {
 176 ''',
 177                       event_enum_name = event_enum_name)
 178
 179     # append automatically generated _MAX value
 180     enum_max_value = c_enum_const(event_enum_name, "MAX")
 181     enum_values = event_enum_values + [ enum_max_value ]
 182
 183     i = 0
 184     for value in enum_values:
 185         enum_decl += mcgen('''
 186     %(value)s = %(i)d,
 187 ''',
 188                      value = value,
 189                      i = i)
 190         i += 1
 191
 192     enum_decl += mcgen('''
 193 } %(event_enum_name)s;
 194 ''',
 195                        event_enum_name = event_enum_name)
 196
 197     return lookup_decl + enum_decl
 198
 199 def generate_event_enum_lookup(event_enum_name, event_enum_strings):
 200     ret = mcgen('''
 201
 202 const char *%(event_enum_name)s_lookup[] = {
 203 ''',
 204                 event_enum_name = event_enum_name)
 205
 206     i = 0
 207     for string in event_enum_strings:
 208         ret += mcgen('''
 209     "%(string)s",
 210 ''',
 211                      string = string)
 212
 213     ret += mcgen('''
 214     NULL,
 215 };
 216 ''')
 217     return ret
 218
 219
 220 # Start the real job
 221
 222 try:
 223     opts, args = getopt.gnu_getopt(sys.argv[1:], "chbp:i:o:",
 224                                    ["source", "header", "builtins", "prefix=",
 225                                     "input-file=", "output-dir="])
 226 except getopt.GetoptError, err:
 227     print str(err)
 228     sys.exit(1)
 229
 230 input_file = ""
 231 output_dir = ""
 232 prefix = ""
 233 c_file = 'qapi-event.c'
 234 h_file = 'qapi-event.h'
 235
 236 do_c = False
 237 do_h = False
 238 do_builtins = False
 239
 240 for o, a in opts:
 241     if o in ("-p", "--prefix"):
 242         prefix = a
 243     elif o in ("-i", "--input-file"):
 244         input_file = a
 245     elif o in ("-o", "--output-dir"):
 246         output_dir = a + "/"
 247     elif o in ("-c", "--source"):
 248         do_c = True
 249     elif o in ("-h", "--header"):
 250         do_h = True
 251     elif o in ("-b", "--builtins"):
 252         do_builtins = True
 253
 254 if not do_c and not do_h:
 255     do_c = True
 256     do_h = True
 257
 258 c_file = output_dir + prefix + c_file
 259 h_file = output_dir + prefix + h_file
 260
 261 try:
 262     os.makedirs(output_dir)
 263 except os.error, e:
 264     if e.errno != errno.EEXIST:
 265         raise
 266
 267 def maybe_open(really, name, opt):
 268     if really:
 269         return open(name, opt)
 270     else:
 271         import StringIO
 272         return StringIO.StringIO()
 273
 274 fdef = maybe_open(do_c, c_file, 'w')
 275 fdecl = maybe_open(do_h, h_file, 'w')
 276
 277 fdef.write(mcgen('''
 278 /* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
 279
 280 /*
 281  * schema-defined QAPI event functions
 282  *
 283  * Copyright (c) 2014 Wenchao Xia
 284  *
 285  * Authors:
 286  *  Wenchao Xia   <wenchaoqemu@gmail.com>
 287  *
 288  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 289  * See the COPYING.LIB file in the top-level directory.
 290  *
 291  */
 292
 293 #include "qemu-common.h"
 294 #include "%(header)s"
 295 #include "%(prefix)sqapi-visit.h"
 296 #include "qapi/qmp-output-visitor.h"
 297 #include "qapi/qmp-event.h"
 298
 299 ''',
 300                  prefix=prefix, header=basename(h_file)))
 301
 302 fdecl.write(mcgen('''
 303 /* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
 304
 305 /*
 306  * schema-defined QAPI event functions
 307  *
 308  * Copyright (c) 2014 Wenchao Xia
 309  *
 310  * Authors:
 311  *  Wenchao Xia  <wenchaoqemu@gmail.com>
 312  *
 313  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 314  * See the COPYING.LIB file in the top-level directory.
 315  *
 316  */
 317
 318 #ifndef %(guard)s
 319 #define %(guard)s
 320
 321 #include "qapi/error.h"
 322 #include "qapi/qmp/qdict.h"
 323 #include "%(prefix)sqapi-types.h"
 324
 325 ''',
 326                   prefix=prefix, guard=guardname(h_file)))
 327
 328 exprs = parse_schema(input_file)
 329
 330 event_enum_name = prefix.upper().replace('-', '_') + "QAPIEvent"
 331 event_enum_values = []
 332 event_enum_strings = []
 333
 334 for expr in exprs:
 335     if expr.has_key('event'):
 336         event_name = expr['event']
 337         params = expr.get('data')
 338         if params and len(params) == 0:
 339             params = None
 340
 341         api_name = _generate_event_api_name(event_name, params)
 342         ret = generate_event_declaration(api_name)
 343         fdecl.write(ret)
 344
 345         # We need an enum value per event
 346         event_enum_value = c_enum_const(event_enum_name, event_name)
 347         ret = generate_event_implement(api_name, event_name, params)
 348         fdef.write(ret)
 349
 350         # Record it, and generate enum later
 351         event_enum_values.append(event_enum_value)
 352         event_enum_strings.append(event_name)
 353
 354 ret = generate_event_enum_decl(event_enum_name, event_enum_values)
 355 fdecl.write(ret)
 356 ret = generate_event_enum_lookup(event_enum_name, event_enum_strings)
 357 fdef.write(ret)
 358
 359 fdecl.write('''
 360 #endif
 361 ''')
 362
 363 fdecl.flush()
 364 fdecl.close()
 365
 366 fdef.flush()
 367 fdef.close()