Return to qapi-dealloc-visitor.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / qapi

Annotation of qemu/qapi/qapi-dealloc-visitor.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Dealloc Visitor
                      3:  *
                      4:  * Copyright IBM, Corp. 2011
                      5:  *
                      6:  * Authors:
                      7:  *  Michael Roth   <[email protected]>
                      8:  *
                      9:  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
                     10:  * See the COPYING.LIB file in the top-level directory.
                     11:  *
                     12:  */
                     13: 
                     14: #include "qapi-dealloc-visitor.h"
                     15: #include "qemu-queue.h"
                     16: #include "qemu-common.h"
                     17: #include "qemu-objects.h"
                     18: 
                     19: typedef struct StackEntry
                     20: {
                     21:     void *value;
                     22:     QTAILQ_ENTRY(StackEntry) node;
                     23: } StackEntry;
                     24: 
                     25: struct QapiDeallocVisitor
                     26: {
                     27:     Visitor visitor;
                     28:     QTAILQ_HEAD(, StackEntry) stack;
                     29: };
                     30: 
                     31: static QapiDeallocVisitor *to_qov(Visitor *v)
                     32: {
                     33:     return container_of(v, QapiDeallocVisitor, visitor);
                     34: }
                     35: 
                     36: static void qapi_dealloc_push(QapiDeallocVisitor *qov, void *value)
                     37: {
                     38:     StackEntry *e = qemu_mallocz(sizeof(*e));
                     39: 
                     40:     e->value = value;
                     41:     QTAILQ_INSERT_HEAD(&qov->stack, e, node);
                     42: }
                     43: 
                     44: static void *qapi_dealloc_pop(QapiDeallocVisitor *qov)
                     45: {
                     46:     StackEntry *e = QTAILQ_FIRST(&qov->stack);
                     47:     QObject *value;
                     48:     QTAILQ_REMOVE(&qov->stack, e, node);
                     49:     value = e->value;
                     50:     qemu_free(e);
                     51:     return value;
                     52: }
                     53: 
                     54: static void qapi_dealloc_start_struct(Visitor *v, void **obj, const char *kind,
                     55:                                       const char *name, size_t unused,
                     56:                                       Error **errp)
                     57: {
                     58:     QapiDeallocVisitor *qov = to_qov(v);
                     59:     qapi_dealloc_push(qov, obj);
                     60: }
                     61: 
                     62: static void qapi_dealloc_end_struct(Visitor *v, Error **errp)
                     63: {
                     64:     QapiDeallocVisitor *qov = to_qov(v);
                     65:     void **obj = qapi_dealloc_pop(qov);
                     66:     if (obj) {
                     67:         qemu_free(*obj);
                     68:     }
                     69: }
                     70: 
                     71: static void qapi_dealloc_start_list(Visitor *v, const char *name, Error **errp)
                     72: {
                     73: }
                     74: 
                     75: static GenericList *qapi_dealloc_next_list(Visitor *v, GenericList **list,
                     76:                                            Error **errp)
                     77: {
                     78:     GenericList *retval = *list;
                     79:     qemu_free(retval->value);
                     80:     *list = retval->next;
                     81:     return retval;
                     82: }
                     83: 
                     84: static void qapi_dealloc_end_list(Visitor *v, Error **errp)
                     85: {
                     86: }
                     87: 
                     88: static void qapi_dealloc_type_str(Visitor *v, char **obj, const char *name,
                     89:                                   Error **errp)
                     90: {
                     91:     if (obj) {
                     92:         qemu_free(*obj);
                     93:     }
                     94: }
                     95: 
                     96: static void qapi_dealloc_type_int(Visitor *v, int64_t *obj, const char *name,
                     97:                                   Error **errp)
                     98: {
                     99: }
                    100: 
                    101: static void qapi_dealloc_type_bool(Visitor *v, bool *obj, const char *name,
                    102:                                    Error **errp)
                    103: {
                    104: }
                    105: 
                    106: static void qapi_dealloc_type_number(Visitor *v, double *obj, const char *name,
                    107:                                      Error **errp)
                    108: {
                    109: }
                    110: 
                    111: static void qapi_dealloc_type_enum(Visitor *v, int *obj, const char *strings[],
                    112:                                    const char *kind, const char *name,
                    113:                                    Error **errp)
                    114: {
                    115: }
                    116: 
                    117: Visitor *qapi_dealloc_get_visitor(QapiDeallocVisitor *v)
                    118: {
                    119:     return &v->visitor;
                    120: }
                    121: 
                    122: void qapi_dealloc_visitor_cleanup(QapiDeallocVisitor *v)
                    123: {
                    124:     qemu_free(v);
                    125: }
                    126: 
                    127: QapiDeallocVisitor *qapi_dealloc_visitor_new(void)
                    128: {
                    129:     QapiDeallocVisitor *v;
                    130: 
                    131:     v = qemu_mallocz(sizeof(*v));
                    132: 
                    133:     v->visitor.start_struct = qapi_dealloc_start_struct;
                    134:     v->visitor.end_struct = qapi_dealloc_end_struct;
                    135:     v->visitor.start_list = qapi_dealloc_start_list;
                    136:     v->visitor.next_list = qapi_dealloc_next_list;
                    137:     v->visitor.end_list = qapi_dealloc_end_list;
                    138:     v->visitor.type_enum = qapi_dealloc_type_enum;
                    139:     v->visitor.type_int = qapi_dealloc_type_int;
                    140:     v->visitor.type_bool = qapi_dealloc_type_bool;
                    141:     v->visitor.type_str = qapi_dealloc_type_str;
                    142:     v->visitor.type_number = qapi_dealloc_type_number;
                    143: 
                    144:     QTAILQ_INIT(&v->stack);
                    145: 
                    146:     return v;
                    147: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.