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     ! 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.