qapi/hmp-output-visitor.c

   1 /*
   2  * HMP string output Visitor
   3  *
   4  * Copyright Yandex N.V., 2021
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  *
   9  */
  10
  11 #include "qemu/osdep.h"
  12 #include "qemu/cutils.h"
  13 #include "qapi/hmp-output-visitor.h"
  14 #include "qapi/visitor-impl.h"
  15
  16 struct HMPOutputVisitor {
  17     Visitor visitor;
  18     char **result;
  19     GString *buffer;
  20     bool is_continue;
  21 };
  22
  23 static HMPOutputVisitor *to_hov(Visitor *v)
  24 {
  25     return container_of(v, HMPOutputVisitor, visitor);
  26 }
  27
  28 static void hmp_output_append_formatted(Visitor *v, const char *fmt, ...)
  29 {
  30     HMPOutputVisitor *ov = to_hov(v);
  31     va_list args;
  32
  33     if (ov->is_continue) {
  34         g_string_append(ov->buffer, ",");
  35     } else {
  36         ov->is_continue = true;
  37     }
  38
  39     va_start(args, fmt);
  40     g_string_append_vprintf(ov->buffer, fmt, args);
  41     va_end(args);
  42 }
  43
  44 static void hmp_output_skip_comma(Visitor *v)
  45 {
  46     HMPOutputVisitor *ov = to_hov(v);
  47
  48     ov->is_continue = false;
  49 }
  50
  51 static bool hmp_output_start_struct(Visitor *v, const char *name,
  52                                     void **obj, size_t unused, Error **errp)
  53 {
  54     return true;
  55 }
  56
  57 static void hmp_output_end_struct(Visitor *v, void **obj) {}
  58
  59 static bool hmp_output_start_list(Visitor *v, const char *name,
  60                                   GenericList **listp, size_t size,
  61                                   Error **errp)
  62 {
  63     hmp_output_append_formatted(v, "%s=[", name);
  64     /* First element in array without comma before it */
  65     hmp_output_skip_comma(v);
  66
  67     return true;
  68 }
  69
  70 static GenericList *hmp_output_next_list(Visitor *v, GenericList *tail,
  71                                          size_t size)
  72 {
  73     return tail->next;
  74 }
  75
  76 static void hmp_output_end_list(Visitor *v, void **obj)
  77 {
  78     /* Don't need comma after last array element */
  79     hmp_output_skip_comma(v);
  80     hmp_output_append_formatted(v, "]");
  81 }
  82
  83 static bool hmp_output_type_int64(Visitor *v, const char *name,
  84                                   int64_t *obj, Error **errp)
  85 {
  86     hmp_output_append_formatted(v, "%s=%" PRId64, name, *obj);
  87
  88     return true;
  89 }
  90
  91 static bool hmp_output_type_uint64(Visitor *v, const char *name,
  92                                    uint64_t *obj, Error **errp)
  93 {
  94     hmp_output_append_formatted(v, "%s=%" PRIu64, name, *obj);
  95
  96     return true;
  97 }
  98
  99 static bool hmp_output_type_bool(Visitor *v, const char *name, bool *obj,
 100                                  Error **errp)
 101 {
 102     hmp_output_append_formatted(v, "%s=%s", name, *obj ? "true" : "false");
 103
 104     return true;
 105 }
 106
 107 static bool hmp_output_type_str(Visitor *v, const char *name, char **obj,
 108                                 Error **errp)
 109 {
 110     /* Skip already printed or unused fields */
 111     if (!*obj || g_str_equal(name, "id") || g_str_equal(name, "type")) {
 112         return true;
 113     }
 114
 115     /* Do not print stub name for StringList elements */
 116     if (g_str_equal(name, "str")) {
 117         hmp_output_append_formatted(v, "%s", *obj);
 118     } else {
 119         hmp_output_append_formatted(v, "%s=%s", name, *obj);
 120     }
 121
 122     return true;
 123 }
 124
 125 static bool hmp_output_type_number(Visitor *v, const char *name,
 126                                    double *obj, Error **errp)
 127 {
 128     hmp_output_append_formatted(v, "%s=%.17g", name, *obj);
 129
 130     return true;
 131 }
 132
 133 /* TODO: remove this function? */
 134 static bool hmp_output_type_any(Visitor *v, const char *name,
 135                                 QObject **obj, Error **errp)
 136 {
 137     return true;
 138 }
 139
 140 static bool hmp_output_type_null(Visitor *v, const char *name,
 141                                  QNull **obj, Error **errp)
 142 {
 143     hmp_output_append_formatted(v, "%s=NULL", name);
 144
 145     return true;
 146 }
 147
 148 static void hmp_output_complete(Visitor *v, void *opaque)
 149 {
 150     HMPOutputVisitor *ov = to_hov(v);
 151
 152     *ov->result = g_string_free(ov->buffer, false);
 153     ov->buffer = NULL;
 154 }
 155
 156 static void hmp_output_free(Visitor *v)
 157 {
 158     HMPOutputVisitor *ov = to_hov(v);
 159
 160     if (ov->buffer) {
 161         g_string_free(ov->buffer, true);
 162     }
 163     g_free(v);
 164 }
 165
 166 Visitor *hmp_output_visitor_new(char **result)
 167 {
 168     HMPOutputVisitor *v;
 169
 170     v = g_malloc0(sizeof(*v));
 171
 172     v->visitor.type = VISITOR_OUTPUT;
 173     v->visitor.start_struct = hmp_output_start_struct;
 174     v->visitor.end_struct = hmp_output_end_struct;
 175     v->visitor.start_list = hmp_output_start_list;
 176     v->visitor.next_list = hmp_output_next_list;
 177     v->visitor.end_list = hmp_output_end_list;
 178     v->visitor.type_int64 = hmp_output_type_int64;
 179     v->visitor.type_uint64 = hmp_output_type_uint64;
 180     v->visitor.type_bool = hmp_output_type_bool;
 181     v->visitor.type_str = hmp_output_type_str;
 182     v->visitor.type_number = hmp_output_type_number;
 183     v->visitor.type_any = hmp_output_type_any;
 184     v->visitor.type_null = hmp_output_type_null;
 185     v->visitor.complete = hmp_output_complete;
 186     v->visitor.free = hmp_output_free;
 187
 188     v->result = result;
 189     v->buffer = g_string_new("");
 190     v->is_continue = false;
 191
 192     return &v->visitor;
 193 }