Return to string-input-visitor.c CVS log

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

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

1.1       root        1: /*
                      2:  * String parsing visitor
                      3:  *
                      4:  * Copyright Red Hat, Inc. 2012
                      5:  *
                      6:  * Author: Paolo Bonzini <[email protected]>
                      7:  *
                      8:  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
                      9:  * See the COPYING.LIB file in the top-level directory.
                     10:  *
                     11:  */
                     12: 
                     13: #include "qemu-common.h"
                     14: #include "string-input-visitor.h"
                     15: #include "qapi/qapi-visit-impl.h"
                     16: #include "qerror.h"
                     17: 
                     18: struct StringInputVisitor
                     19: {
                     20:     Visitor visitor;
                     21:     const char *string;
                     22: };
                     23: 
                     24: static void parse_type_int(Visitor *v, int64_t *obj, const char *name,
                     25:                            Error **errp)
                     26: {
                     27:     StringInputVisitor *siv = DO_UPCAST(StringInputVisitor, visitor, v);
                     28:     char *endp = (char *) siv->string;
                     29:     long long val;
                     30: 
                     31:     errno = 0;
                     32:     if (siv->string) {
                     33:         val = strtoll(siv->string, &endp, 0);
                     34:     }
                     35:     if (!siv->string || errno || endp == siv->string || *endp) {
                     36:         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                     37:                   "integer");
                     38:         return;
                     39:     }
                     40: 
                     41:     *obj = val;
                     42: }
                     43: 
                     44: static void parse_type_bool(Visitor *v, bool *obj, const char *name,
                     45:                             Error **errp)
                     46: {
                     47:     StringInputVisitor *siv = DO_UPCAST(StringInputVisitor, visitor, v);
                     48: 
                     49:     if (siv->string) {
                     50:         if (!strcasecmp(siv->string, "on") ||
                     51:             !strcasecmp(siv->string, "yes") ||
                     52:             !strcasecmp(siv->string, "true")) {
                     53:             *obj = true;
                     54:             return;
                     55:         }
                     56:         if (!strcasecmp(siv->string, "off") ||
                     57:             !strcasecmp(siv->string, "no") ||
                     58:             !strcasecmp(siv->string, "false")) {
                     59:             *obj = false;
                     60:             return;
                     61:         }
                     62:     }
                     63: 
                     64:     error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                     65:               "boolean");
                     66: }
                     67: 
                     68: static void parse_type_str(Visitor *v, char **obj, const char *name,
                     69:                            Error **errp)
                     70: {
                     71:     StringInputVisitor *siv = DO_UPCAST(StringInputVisitor, visitor, v);
                     72:     if (siv->string) {
                     73:         *obj = g_strdup(siv->string);
                     74:     } else {
                     75:         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                     76:                   "string");
                     77:     }
                     78: }
                     79: 
                     80: static void parse_type_number(Visitor *v, double *obj, const char *name,
                     81:                               Error **errp)
                     82: {
                     83:     StringInputVisitor *siv = DO_UPCAST(StringInputVisitor, visitor, v);
                     84:     char *endp = (char *) siv->string;
                     85:     double val;
                     86: 
                     87:     errno = 0;
                     88:     if (siv->string) {
                     89:         val = strtod(siv->string, &endp);
                     90:     }
                     91:     if (!siv->string || errno || endp == siv->string || *endp) {
                     92:         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                     93:                   "number");
                     94:         return;
                     95:     }
                     96: 
                     97:     *obj = val;
                     98: }
                     99: 
                    100: static void parse_start_optional(Visitor *v, bool *present,
                    101:                                  const char *name, Error **errp)
                    102: {
                    103:     StringInputVisitor *siv = DO_UPCAST(StringInputVisitor, visitor, v);
                    104: 
                    105:     if (!siv->string) {
                    106:         *present = false;
                    107:         return;
                    108:     }
                    109: 
                    110:     *present = true;
                    111: }
                    112: 
                    113: Visitor *string_input_get_visitor(StringInputVisitor *v)
                    114: {
                    115:     return &v->visitor;
                    116: }
                    117: 
                    118: void string_input_visitor_cleanup(StringInputVisitor *v)
                    119: {
                    120:     g_free(v);
                    121: }
                    122: 
                    123: StringInputVisitor *string_input_visitor_new(const char *str)
                    124: {
                    125:     StringInputVisitor *v;
                    126: 
                    127:     v = g_malloc0(sizeof(*v));
                    128: 
                    129:     v->visitor.type_enum = input_type_enum;
                    130:     v->visitor.type_int = parse_type_int;
                    131:     v->visitor.type_bool = parse_type_bool;
                    132:     v->visitor.type_str = parse_type_str;
                    133:     v->visitor.type_number = parse_type_number;
                    134:     v->visitor.start_optional = parse_start_optional;
                    135: 
                    136:     v->string = str;
                    137:     return v;
                    138: }

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