Something went wrong. Try again.
🎥 Command line media player
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312/* * This file is part of mpv. * * mpv is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * mpv is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with mpv. If not, see <http://www.gnu.org/licenses/>. */
/* JSON parser: * * Unlike standard JSON, \u escapes don't allow you to specify UTF-16 surrogate * pairs. There may be some differences how numbers are parsed (this parser * doesn't verify what's passed to strtod(), and also prefers parsing numbers * as integers with stroll() if possible). * * Does not support extensions like unquoted string literals. * * Also see: http://tools.ietf.org/html/rfc4627 * * JSON writer: * * Doesn't insert whitespace. It's literally a waste of space. * * Can output invalid UTF-8, if input is invalid UTF-8. Consumers are supposed * to deal with somehow: either by using byte-strings for JSON, or by running * a "fixup" pass on the input data. The latter could for example change * invalid UTF-8 sequences to replacement characters. * * Currently, will insert \u literals for characters 0-31, '"', '\', and write * everything else literally. */
#include <stdlib.h>#include <string.h>#include <math.h>#include <errno.h>#include <inttypes.h>#include <assert.h>
#include "common/common.h"#include "misc/bstr.h"
#include "json.h"
static bool eat_c(char **s, char c){ if (**s == c) { *s += 1; return true; } return false;}
static void eat_ws(char **src){ while (1) { char c = **src; if (c != ' ' && c != '\t' && c != '\n' && c != '\r') return; *src += 1; }}
void json_skip_whitespace(char **src){ eat_ws(src);}
static int read_str(void *ta_parent, struct mpv_node *dst, char **src){ if (!eat_c(src, '"')) return -1; // not a string char *str = *src; char *cur = str; bool has_escapes = false; while (cur[0] && cur[0] != '"') { if (cur[0] == '\\') { has_escapes = true; // skip >\"< and >\\< (latter to handle >\\"< correctly) if (cur[1] == '"' || cur[1] == '\\') cur++; } cur++; } if (cur[0] != '"') return -1; // invalid termination // Mutate input string so we have a null-terminated string to the literal. // This is a stupid micro-optimization, so we can avoid allocation. cur[0] = '\0'; *src = cur + 1; if (has_escapes) { bstr unescaped = {0}; bstr r = bstr0(str); if (!mp_append_escaped_string(ta_parent, &unescaped, &r)) return -1; // broken escapes str = unescaped.start; // the function guarantees null-termination } dst->format = MPV_FORMAT_STRING; dst->u.string = str; return 0;}
static int read_sub(void *ta_parent, struct mpv_node *dst, char **src, int max_depth){ bool is_arr = eat_c(src, '['); bool is_obj = !is_arr && eat_c(src, '{'); if (!is_arr && !is_obj) return -1; // not an array or object char term = is_obj ? '}' : ']'; struct mpv_node_list *list = talloc_zero(ta_parent, struct mpv_node_list); while (1) { eat_ws(src); if (eat_c(src, term)) break; if (list->num > 0 && !eat_c(src, ',')) return -1; // missing ',' eat_ws(src); if (is_obj) { struct mpv_node keynode; if (read_str(list, &keynode, src) < 0) return -1; // key is not a string eat_ws(src); if (!eat_c(src, ':')) return -1; // ':' missing eat_ws(src); MP_TARRAY_GROW(list, list->keys, list->num); list->keys[list->num] = keynode.u.string; } MP_TARRAY_GROW(list, list->values, list->num); if (json_parse(ta_parent, &list->values[list->num], src, max_depth) < 0) return -1; list->num++; } dst->format = is_obj ? MPV_FORMAT_NODE_MAP : MPV_FORMAT_NODE_ARRAY; dst->u.list = list; return 0;}
/* Parse the string in *src as JSON, and write the result into *dst. * max_depth limits the recursion and JSON tree depth. * Warning: this overwrites the input string (what *src points to)! * Returns: * 0: success, *dst is valid, *src points to the end (the caller must check * whether *src really terminates) * -1: failure, *dst is invalid, there may be dead allocs under ta_parent * (ta_free_children(ta_parent) is the only way to free them) * The input string can be mutated in both cases. *dst might contain string * elements, which point into the (mutated) input string. */int json_parse(void *ta_parent, struct mpv_node *dst, char **src, int max_depth){ max_depth -= 1; if (max_depth < 0) return -1;
eat_ws(src);
char c = **src; if (!c) return -1; // early EOF if (c == 'n' && strncmp(*src, "null", 4) == 0) { *src += 4; dst->format = MPV_FORMAT_NONE; return 0; } else if (c == 't' && strncmp(*src, "true", 4) == 0) { *src += 4; dst->format = MPV_FORMAT_FLAG; dst->u.flag = 1; return 0; } else if (c == 'f' && strncmp(*src, "false", 5) == 0) { *src += 5; dst->format = MPV_FORMAT_FLAG; dst->u.flag = 0; return 0; } else if (c == '"') { return read_str(ta_parent, dst, src); } else if (c == '[' || c == '{') { return read_sub(ta_parent, dst, src, max_depth); } else if (c == '-' || (c >= '0' && c <= '9')) { // The number could be either a float or an int. JSON doesn't make a // difference, but the client API does. char *nsrci = *src, *nsrcf = *src; errno = 0; long long int numi = strtoll(*src, &nsrci, 0); if (errno) nsrci = *src; errno = 0; double numf = strtod(*src, &nsrcf); if (errno) nsrcf = *src; if (nsrci >= nsrcf) { *src = nsrci; dst->format = MPV_FORMAT_INT64; // long long is usually 64 bits dst->u.int64 = numi; return 0; } if (nsrcf > *src && isfinite(numf)) { *src = nsrcf; dst->format = MPV_FORMAT_DOUBLE; dst->u.double_ = numf; return 0; } return -1; } return -1; // character doesn't start a valid token}
#define APPEND(b, s) bstr_xappend(NULL, (b), bstr0(s))
static void write_json_str(bstr *b, unsigned char *str){ APPEND(b, "\""); while (1) { unsigned char *cur = str; while (cur[0] >= 32 && cur[0] != '"' && cur[0] != '\\') cur++; if (!cur[0]) break; bstr_xappend(NULL, b, (bstr){str, cur - str}); bstr_xappend_asprintf(NULL, b, "\\u%04x", (unsigned char)cur[0]); str = cur + 1; } APPEND(b, str); APPEND(b, "\"");}
static void add_indent(bstr *b, int indent){ if (indent < 0) return; bstr_xappend(NULL, b, bstr0("\n")); for (int n = 0; n < indent; n++) bstr_xappend(NULL, b, bstr0(" "));}
static int json_append(bstr *b, const struct mpv_node *src, int indent){ switch (src->format) { case MPV_FORMAT_NONE: APPEND(b, "null"); return 0; case MPV_FORMAT_FLAG: APPEND(b, src->u.flag ? "true" : "false"); return 0; case MPV_FORMAT_INT64: bstr_xappend_asprintf(NULL, b, "%"PRId64, src->u.int64); return 0; case MPV_FORMAT_DOUBLE: bstr_xappend_asprintf(NULL, b, "%f", src->u.double_); return 0; case MPV_FORMAT_STRING: write_json_str(b, src->u.string); return 0; case MPV_FORMAT_NODE_ARRAY: case MPV_FORMAT_NODE_MAP: { struct mpv_node_list *list = src->u.list; bool is_obj = src->format == MPV_FORMAT_NODE_MAP; APPEND(b, is_obj ? "{" : "["); int next_indent = indent >= 0 ? indent + 1 : -1; for (int n = 0; n < list->num; n++) { if (n) APPEND(b, ","); add_indent(b, next_indent); if (is_obj) { write_json_str(b, list->keys[n]); APPEND(b, ":"); } json_append(b, &list->values[n], next_indent); } add_indent(b, indent); APPEND(b, is_obj ? "}" : "]"); return 0; } } return -1; // unknown format}
static int json_append_str(char **dst, struct mpv_node *src, int indent){ bstr buffer = bstr0(*dst); int r = json_append(&buffer, src, indent); *dst = buffer.start; return r;}
/* Write the contents of *src as JSON, and append the JSON string to *dst. * This will use strlen() to determine the start offset, and ta_get_size() * and ta_realloc() to extend the memory allocation of *dst. * Returns: 0 on success, <0 on failure. */int json_write(char **dst, struct mpv_node *src){ return json_append_str(dst, src, -1);}
// Same as json_write(), but add whitespace to make it readable.int json_write_pretty(char **dst, struct mpv_node *src){ return json_append_str(dst, src, 0);}