migration/savevm: load_header before load_setup

[mirror_qemu.git] / qobject / json-parser.c

diff --git a/qobject/json-parser.c b/qobject/json-parser.c
index 864cb578d857c22d7f4dbce2b17683103f0e1d0a..d8eb210c0c7e784d67ec695a483a080b71f3c203 100644 (file)
--- a/qobject/json-parser.c
+++ b/qobject/json-parser.c
@@ -22,15 +22,21 @@
 #include "qapi/qmp/qnull.h"
 #include "qapi/qmp/qnum.h"
 #include "qapi/qmp/qstring.h"
-#include "qapi/qmp/json-parser.h"
-#include "qapi/qmp/json-lexer.h"
-#include "qapi/qmp/json-streamer.h"
+#include "json-parser-int.h"
+
+struct JSONToken {
+    JSONTokenType type;
+    int x;
+    int y;
+    char str[];
+};
 
 typedef struct JSONParserContext
 {
     Error *err;
     JSONToken *current;
     GQueue *buf;
+    va_list *ap;
 } JSONParserContext;
 
 #define BUG_ON(cond) assert(!(cond))
@@ -44,7 +50,7 @@ typedef struct JSONParserContext
  * 4) deal with premature EOI
  */
 
-static QObject *parse_value(JSONParserContext *ctxt, va_list *ap);
+static QObject *parse_value(JSONParserContext *ctxt);
 
 /**
  * Error handler
@@ -138,7 +144,8 @@ static QString *parse_string(JSONParserContext *ctxt, JSONToken *token)
 
     while (*ptr != quote) {
         assert(*ptr);
-        if (*ptr == '\\') {
+        switch (*ptr) {
+        case '\\':
             beg = ptr++;
             switch (*ptr++) {
             case '"':
@@ -199,7 +206,17 @@ static QString *parse_string(JSONParserContext *ctxt, JSONToken *token)
                 parse_error(ctxt, token, "invalid escape sequence in string");
                 goto out;
             }
-        } else {
+            break;
+        case '%':
+            if (ctxt->ap) {
+                if (ptr[1] != '%') {
+                    parse_error(ctxt, token, "can't interpolate into string");
+                    goto out;
+                }
+                ptr++;
+            }
+            /* fall through */
+        default:
             cp = mod_utf8_codepoint(ptr, 6, &end);
             if (cp < 0) {
                 parse_error(ctxt, token, "invalid UTF-8 sequence in string");
@@ -226,21 +243,19 @@ out:
 static JSONToken *parser_context_pop_token(JSONParserContext *ctxt)
 {
     g_free(ctxt->current);
-    assert(!g_queue_is_empty(ctxt->buf));
     ctxt->current = g_queue_pop_head(ctxt->buf);
     return ctxt->current;
 }
 
 static JSONToken *parser_context_peek_token(JSONParserContext *ctxt)
 {
-    assert(!g_queue_is_empty(ctxt->buf));
     return g_queue_peek_head(ctxt->buf);
 }
 
 /**
  * Parsing rules
  */
-static int parse_pair(JSONParserContext *ctxt, QDict *dict, va_list *ap)
+static int parse_pair(JSONParserContext *ctxt, QDict *dict)
 {
     QObject *value;
     QString *key = NULL;
@@ -252,7 +267,7 @@ static int parse_pair(JSONParserContext *ctxt, QDict *dict, va_list *ap)
         goto out;
     }
 
-    key = qobject_to(QString, parse_value(ctxt, ap));
+    key = qobject_to(QString, parse_value(ctxt));
     if (!key) {
         parse_error(ctxt, peek, "key is not a string in object");
         goto out;
@@ -269,12 +284,17 @@ static int parse_pair(JSONParserContext *ctxt, QDict *dict, va_list *ap)
         goto out;
     }
 
-    value = parse_value(ctxt, ap);
+    value = parse_value(ctxt);
     if (value == NULL) {
         parse_error(ctxt, token, "Missing value in dict");
         goto out;
     }
 
+    if (qdict_haskey(dict, qstring_get_str(key))) {
+        parse_error(ctxt, token, "duplicate key");
+        goto out;
+    }
+
     qdict_put_obj(dict, qstring_get_str(key), value);
 
     qobject_unref(key);
@@ -287,7 +307,7 @@ out:
     return -1;
 }
 
-static QObject *parse_object(JSONParserContext *ctxt, va_list *ap)
+static QObject *parse_object(JSONParserContext *ctxt)
 {
     QDict *dict = NULL;
     JSONToken *token, *peek;
@@ -304,7 +324,7 @@ static QObject *parse_object(JSONParserContext *ctxt, va_list *ap)
     }
 
     if (peek->type != JSON_RCURLY) {
-        if (parse_pair(ctxt, dict, ap) == -1) {
+        if (parse_pair(ctxt, dict) == -1) {
             goto out;
         }
 
@@ -320,7 +340,7 @@ static QObject *parse_object(JSONParserContext *ctxt, va_list *ap)
                 goto out;
             }
 
-            if (parse_pair(ctxt, dict, ap) == -1) {
+            if (parse_pair(ctxt, dict) == -1) {
                 goto out;
             }
 
@@ -341,7 +361,7 @@ out:
     return NULL;
 }
 
-static QObject *parse_array(JSONParserContext *ctxt, va_list *ap)
+static QObject *parse_array(JSONParserContext *ctxt)
 {
     QList *list = NULL;
     JSONToken *token, *peek;
@@ -360,7 +380,7 @@ static QObject *parse_array(JSONParserContext *ctxt, va_list *ap)
     if (peek->type != JSON_RSQUARE) {
         QObject *obj;
 
-        obj = parse_value(ctxt, ap);
+        obj = parse_value(ctxt);
         if (obj == NULL) {
             parse_error(ctxt, token, "expecting value");
             goto out;
@@ -380,7 +400,7 @@ static QObject *parse_array(JSONParserContext *ctxt, va_list *ap)
                 goto out;
             }
 
-            obj = parse_value(ctxt, ap);
+            obj = parse_value(ctxt);
             if (obj == NULL) {
                 parse_error(ctxt, token, "expecting value");
                 goto out;
@@ -423,40 +443,39 @@ static QObject *parse_keyword(JSONParserContext *ctxt)
     return NULL;
 }
 
-static QObject *parse_interpolation(JSONParserContext *ctxt, va_list *ap)
+static QObject *parse_interpolation(JSONParserContext *ctxt)
 {
     JSONToken *token;
 
-    if (ap == NULL) {
-        return NULL;
-    }
-
     token = parser_context_pop_token(ctxt);
     assert(token && token->type == JSON_INTERP);
 
     if (!strcmp(token->str, "%p")) {
-        return va_arg(*ap, QObject *);
+        return va_arg(*ctxt->ap, QObject *);
     } else if (!strcmp(token->str, "%i")) {
-        return QOBJECT(qbool_from_bool(va_arg(*ap, int)));
+        return QOBJECT(qbool_from_bool(va_arg(*ctxt->ap, int)));
     } else if (!strcmp(token->str, "%d")) {
-        return QOBJECT(qnum_from_int(va_arg(*ap, int)));
+        return QOBJECT(qnum_from_int(va_arg(*ctxt->ap, int)));
     } else if (!strcmp(token->str, "%ld")) {
-        return QOBJECT(qnum_from_int(va_arg(*ap, long)));
-    } else if (!strcmp(token->str, "%lld") ||
-               !strcmp(token->str, "%I64d")) {
-        return QOBJECT(qnum_from_int(va_arg(*ap, long long)));
+        return QOBJECT(qnum_from_int(va_arg(*ctxt->ap, long)));
+    } else if (!strcmp(token->str, "%lld")) {
+        return QOBJECT(qnum_from_int(va_arg(*ctxt->ap, long long)));
+    } else if (!strcmp(token->str, "%" PRId64)) {
+        return QOBJECT(qnum_from_int(va_arg(*ctxt->ap, int64_t)));
     } else if (!strcmp(token->str, "%u")) {
-        return QOBJECT(qnum_from_uint(va_arg(*ap, unsigned int)));
+        return QOBJECT(qnum_from_uint(va_arg(*ctxt->ap, unsigned int)));
     } else if (!strcmp(token->str, "%lu")) {
-        return QOBJECT(qnum_from_uint(va_arg(*ap, unsigned long)));
-    } else if (!strcmp(token->str, "%llu") ||
-               !strcmp(token->str, "%I64u")) {
-        return QOBJECT(qnum_from_uint(va_arg(*ap, unsigned long long)));
+        return QOBJECT(qnum_from_uint(va_arg(*ctxt->ap, unsigned long)));
+    } else if (!strcmp(token->str, "%llu")) {
+        return QOBJECT(qnum_from_uint(va_arg(*ctxt->ap, unsigned long long)));
+    } else if (!strcmp(token->str, "%" PRIu64)) {
+        return QOBJECT(qnum_from_uint(va_arg(*ctxt->ap, uint64_t)));
     } else if (!strcmp(token->str, "%s")) {
-        return QOBJECT(qstring_from_str(va_arg(*ap, const char *)));
+        return QOBJECT(qstring_from_str(va_arg(*ctxt->ap, const char *)));
     } else if (!strcmp(token->str, "%f")) {
-        return QOBJECT(qnum_from_double(va_arg(*ap, double)));
+        return QOBJECT(qnum_from_double(va_arg(*ctxt->ap, double)));
     }
+    parse_error(ctxt, token, "invalid interpolation '%s'", token->str);
     return NULL;
 }
 
@@ -504,7 +523,7 @@ static QObject *parse_literal(JSONParserContext *ctxt)
     }
     case JSON_FLOAT:
         /* FIXME dependent on locale; a pervasive issue in QEMU */
-        /* FIXME our lexer matches RFC 7159 in forbidding Inf or NaN,
+        /* FIXME our lexer matches RFC 8259 in forbidding Inf or NaN,
          * but those might be useful extensions beyond JSON */
         return QOBJECT(qnum_from_double(strtod(token->str, NULL)));
     default:
@@ -512,7 +531,7 @@ static QObject *parse_literal(JSONParserContext *ctxt)
     }
 }
 
-static QObject *parse_value(JSONParserContext *ctxt, va_list *ap)
+static QObject *parse_value(JSONParserContext *ctxt)
 {
     JSONToken *token;
 
@@ -524,11 +543,11 @@ static QObject *parse_value(JSONParserContext *ctxt, va_list *ap)
 
     switch (token->type) {
     case JSON_LCURLY:
-        return parse_object(ctxt, ap);
+        return parse_object(ctxt);
     case JSON_LSQUARE:
-        return parse_array(ctxt, ap);
+        return parse_array(ctxt);
     case JSON_INTERP:
-        return parse_interpolation(ctxt, ap);
+        return parse_interpolation(ctxt);
     case JSON_INTEGER:
     case JSON_FLOAT:
     case JSON_STRING:
@@ -541,12 +560,25 @@ static QObject *parse_value(JSONParserContext *ctxt, va_list *ap)
     }
 }
 
+JSONToken *json_token(JSONTokenType type, int x, int y, GString *tokstr)
+{
+    JSONToken *token = g_malloc(sizeof(JSONToken) + tokstr->len + 1);
+
+    token->type = type;
+    memcpy(token->str, tokstr->str, tokstr->len);
+    token->str[tokstr->len] = 0;
+    token->x = x;
+    token->y = y;
+    return token;
+}
+
 QObject *json_parser_parse(GQueue *tokens, va_list *ap, Error **errp)
 {
-    JSONParserContext ctxt = { .buf = tokens };
+    JSONParserContext ctxt = { .buf = tokens, .ap = ap };
     QObject *result;
 
-    result = parse_value(&ctxt, ap);
+    result = parse_value(&ctxt);
+    assert(ctxt.err || g_queue_is_empty(ctxt.buf));
 
     error_propagate(errp, ctxt.err);
 
@@ -554,7 +586,6 @@ QObject *json_parser_parse(GQueue *tokens, va_list *ap, Error **errp)
         parser_context_pop_token(&ctxt);
     }
     g_free(ctxt.current);
-    g_queue_free(ctxt.buf);
 
     return result;
 }