|
|
|
// Protocol Buffers - Google's data interchange format
|
|
|
|
// Copyright 2023 Google LLC. All rights reserved.
|
|
|
|
//
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file or at
|
|
|
|
// https://developers.google.com/open-source/licenses/bsd
|
|
|
|
|
|
|
|
#include "upb/json/decode.h"
|
|
|
|
|
|
|
|
#include <errno.h>
|
|
|
|
#include <float.h>
|
|
|
|
#include <inttypes.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <math.h>
|
|
|
|
#include <setjmp.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "upb/base/descriptor_constants.h"
|
|
|
|
#include "upb/base/status.h"
|
|
|
|
#include "upb/base/string_view.h"
|
|
|
|
#include "upb/lex/atoi.h"
|
|
|
|
#include "upb/lex/unicode.h"
|
|
|
|
#include "upb/mem/arena.h"
|
|
|
|
#include "upb/message/array.h"
|
|
|
|
#include "upb/message/map.h"
|
|
|
|
#include "upb/message/message.h"
|
|
|
|
#include "upb/mini_table/message.h"
|
|
|
|
#include "upb/reflection/def.h"
|
|
|
|
#include "upb/reflection/message.h"
|
|
|
|
#include "upb/wire/encode.h"
|
|
|
|
|
|
|
|
// Must be last.
|
|
|
|
#include "upb/port/def.inc"
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
const char *ptr, *end;
|
|
|
|
upb_Arena* arena; /* TODO: should we have a tmp arena for tmp data? */
|
|
|
|
const upb_DefPool* symtab;
|
|
|
|
int depth;
|
|
|
|
int result;
|
|
|
|
upb_Status* status;
|
|
|
|
jmp_buf err;
|
|
|
|
int line;
|
|
|
|
const char* line_begin;
|
|
|
|
bool is_first;
|
|
|
|
int options;
|
|
|
|
const upb_FieldDef* debug_field;
|
|
|
|
} jsondec;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
upb_MessageValue value;
|
|
|
|
bool ignore;
|
|
|
|
} upb_JsonMessageValue;
|
|
|
|
|
|
|
|
enum { JD_OBJECT, JD_ARRAY, JD_STRING, JD_NUMBER, JD_TRUE, JD_FALSE, JD_NULL };
|
|
|
|
|
|
|
|
/* Forward declarations of mutually-recursive functions. */
|
|
|
|
static void jsondec_wellknown(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m);
|
|
|
|
static upb_JsonMessageValue jsondec_value(jsondec* d, const upb_FieldDef* f);
|
|
|
|
static void jsondec_wellknownvalue(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m);
|
|
|
|
static void jsondec_object(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m);
|
|
|
|
|
|
|
|
static bool jsondec_streql(upb_StringView str, const char* lit) {
|
|
|
|
return str.size == strlen(lit) && memcmp(str.data, lit, str.size) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool jsondec_isnullvalue(const upb_FieldDef* f) {
|
|
|
|
return upb_FieldDef_CType(f) == kUpb_CType_Enum &&
|
|
|
|
strcmp(upb_EnumDef_FullName(upb_FieldDef_EnumSubDef(f)),
|
|
|
|
"google.protobuf.NullValue") == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool jsondec_isvalue(const upb_FieldDef* f) {
|
|
|
|
return (upb_FieldDef_CType(f) == kUpb_CType_Message &&
|
|
|
|
upb_MessageDef_WellKnownType(upb_FieldDef_MessageSubDef(f)) ==
|
|
|
|
kUpb_WellKnown_Value) ||
|
|
|
|
jsondec_isnullvalue(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_seterrmsg(jsondec* d, const char* msg) {
|
|
|
|
upb_Status_SetErrorFormat(d->status, "Error parsing JSON @%d:%d: %s", d->line,
|
|
|
|
(int)(d->ptr - d->line_begin), msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
UPB_NORETURN static void jsondec_err(jsondec* d, const char* msg) {
|
|
|
|
jsondec_seterrmsg(d, msg);
|
|
|
|
UPB_LONGJMP(d->err, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
UPB_PRINTF(2, 3)
|
|
|
|
UPB_NORETURN static void jsondec_errf(jsondec* d, const char* fmt, ...) {
|
|
|
|
va_list argp;
|
|
|
|
upb_Status_SetErrorFormat(d->status, "Error parsing JSON @%d:%d: ", d->line,
|
|
|
|
(int)(d->ptr - d->line_begin));
|
|
|
|
va_start(argp, fmt);
|
|
|
|
upb_Status_VAppendErrorFormat(d->status, fmt, argp);
|
|
|
|
va_end(argp);
|
|
|
|
UPB_LONGJMP(d->err, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Advances d->ptr until the next non-whitespace character or to the end of
|
|
|
|
// the buffer.
|
|
|
|
static void jsondec_consumews(jsondec* d) {
|
|
|
|
while (d->ptr != d->end) {
|
|
|
|
switch (*d->ptr) {
|
|
|
|
case '\n':
|
|
|
|
d->line++;
|
|
|
|
d->line_begin = d->ptr;
|
|
|
|
/* Fallthrough. */
|
|
|
|
case '\r':
|
|
|
|
case '\t':
|
|
|
|
case ' ':
|
|
|
|
d->ptr++;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Advances d->ptr until the next non-whitespace character. Postcondition that
|
|
|
|
// d->ptr is pointing at a valid non-whitespace character (will err if end of
|
|
|
|
// buffer is reached).
|
|
|
|
static void jsondec_skipws(jsondec* d) {
|
|
|
|
jsondec_consumews(d);
|
|
|
|
if (d->ptr == d->end) {
|
|
|
|
jsondec_err(d, "Unexpected EOF");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool jsondec_tryparsech(jsondec* d, char ch) {
|
|
|
|
if (d->ptr == d->end || *d->ptr != ch) return false;
|
|
|
|
d->ptr++;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_parselit(jsondec* d, const char* lit) {
|
|
|
|
size_t avail = d->end - d->ptr;
|
|
|
|
size_t len = strlen(lit);
|
|
|
|
if (avail < len || memcmp(d->ptr, lit, len) != 0) {
|
|
|
|
jsondec_errf(d, "Expected: '%s'", lit);
|
|
|
|
}
|
|
|
|
d->ptr += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_wsch(jsondec* d, char ch) {
|
|
|
|
jsondec_skipws(d);
|
|
|
|
if (!jsondec_tryparsech(d, ch)) {
|
|
|
|
jsondec_errf(d, "Expected: '%c'", ch);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_true(jsondec* d) { jsondec_parselit(d, "true"); }
|
|
|
|
static void jsondec_false(jsondec* d) { jsondec_parselit(d, "false"); }
|
|
|
|
static void jsondec_null(jsondec* d) { jsondec_parselit(d, "null"); }
|
|
|
|
|
|
|
|
static void jsondec_entrysep(jsondec* d) {
|
|
|
|
jsondec_skipws(d);
|
|
|
|
jsondec_parselit(d, ":");
|
|
|
|
}
|
|
|
|
|
|
|
|
static int jsondec_rawpeek(jsondec* d) {
|
|
|
|
if (d->ptr == d->end) {
|
|
|
|
jsondec_err(d, "Unexpected EOF");
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (*d->ptr) {
|
|
|
|
case '{':
|
|
|
|
return JD_OBJECT;
|
|
|
|
case '[':
|
|
|
|
return JD_ARRAY;
|
|
|
|
case '"':
|
|
|
|
return JD_STRING;
|
|
|
|
case '-':
|
|
|
|
case '0':
|
|
|
|
case '1':
|
|
|
|
case '2':
|
|
|
|
case '3':
|
|
|
|
case '4':
|
|
|
|
case '5':
|
|
|
|
case '6':
|
|
|
|
case '7':
|
|
|
|
case '8':
|
|
|
|
case '9':
|
|
|
|
return JD_NUMBER;
|
|
|
|
case 't':
|
|
|
|
return JD_TRUE;
|
|
|
|
case 'f':
|
|
|
|
return JD_FALSE;
|
|
|
|
case 'n':
|
|
|
|
return JD_NULL;
|
|
|
|
default:
|
|
|
|
jsondec_errf(d, "Unexpected character: '%c'", *d->ptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* JSON object/array **********************************************************/
|
|
|
|
|
|
|
|
/* These are used like so:
|
|
|
|
*
|
|
|
|
* jsondec_objstart(d);
|
|
|
|
* while (jsondec_objnext(d)) {
|
|
|
|
* ...
|
|
|
|
* }
|
|
|
|
* jsondec_objend(d) */
|
|
|
|
|
|
|
|
static int jsondec_peek(jsondec* d) {
|
|
|
|
jsondec_skipws(d);
|
|
|
|
return jsondec_rawpeek(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_push(jsondec* d) {
|
|
|
|
if (--d->depth < 0) {
|
|
|
|
jsondec_err(d, "Recursion limit exceeded");
|
|
|
|
}
|
|
|
|
d->is_first = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool jsondec_seqnext(jsondec* d, char end_ch) {
|
|
|
|
bool is_first = d->is_first;
|
|
|
|
d->is_first = false;
|
|
|
|
jsondec_skipws(d);
|
|
|
|
if (*d->ptr == end_ch) return false;
|
|
|
|
if (!is_first) jsondec_parselit(d, ",");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_arrstart(jsondec* d) {
|
|
|
|
jsondec_push(d);
|
|
|
|
jsondec_wsch(d, '[');
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_arrend(jsondec* d) {
|
|
|
|
d->depth++;
|
|
|
|
jsondec_wsch(d, ']');
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool jsondec_arrnext(jsondec* d) { return jsondec_seqnext(d, ']'); }
|
|
|
|
|
|
|
|
static void jsondec_objstart(jsondec* d) {
|
|
|
|
jsondec_push(d);
|
|
|
|
jsondec_wsch(d, '{');
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_objend(jsondec* d) {
|
|
|
|
d->depth++;
|
|
|
|
jsondec_wsch(d, '}');
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool jsondec_objnext(jsondec* d) {
|
|
|
|
if (!jsondec_seqnext(d, '}')) return false;
|
|
|
|
if (jsondec_peek(d) != JD_STRING) {
|
|
|
|
jsondec_err(d, "Object must start with string");
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* JSON number ****************************************************************/
|
|
|
|
|
|
|
|
static bool jsondec_tryskipdigits(jsondec* d) {
|
|
|
|
const char* start = d->ptr;
|
|
|
|
|
|
|
|
while (d->ptr < d->end) {
|
|
|
|
if (*d->ptr < '0' || *d->ptr > '9') {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
d->ptr++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return d->ptr != start;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_skipdigits(jsondec* d) {
|
|
|
|
if (!jsondec_tryskipdigits(d)) {
|
|
|
|
jsondec_err(d, "Expected one or more digits");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static double jsondec_number(jsondec* d) {
|
|
|
|
const char* start = d->ptr;
|
|
|
|
|
|
|
|
UPB_ASSERT(jsondec_rawpeek(d) == JD_NUMBER);
|
|
|
|
|
|
|
|
/* Skip over the syntax of a number, as specified by JSON. */
|
|
|
|
if (*d->ptr == '-') d->ptr++;
|
|
|
|
|
|
|
|
if (jsondec_tryparsech(d, '0')) {
|
|
|
|
if (jsondec_tryskipdigits(d)) {
|
|
|
|
jsondec_err(d, "number cannot have leading zero");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
jsondec_skipdigits(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (d->ptr == d->end) goto parse;
|
|
|
|
if (jsondec_tryparsech(d, '.')) {
|
|
|
|
jsondec_skipdigits(d);
|
|
|
|
}
|
|
|
|
if (d->ptr == d->end) goto parse;
|
|
|
|
|
|
|
|
if (*d->ptr == 'e' || *d->ptr == 'E') {
|
|
|
|
d->ptr++;
|
|
|
|
if (d->ptr == d->end) {
|
|
|
|
jsondec_err(d, "Unexpected EOF in number");
|
|
|
|
}
|
|
|
|
if (*d->ptr == '+' || *d->ptr == '-') {
|
|
|
|
d->ptr++;
|
|
|
|
}
|
|
|
|
jsondec_skipdigits(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
parse:
|
|
|
|
/* Having verified the syntax of a JSON number, use strtod() to parse
|
|
|
|
* (strtod() accepts a superset of JSON syntax). */
|
|
|
|
errno = 0;
|
|
|
|
{
|
|
|
|
// Copy the number into a null-terminated scratch buffer since strtod
|
|
|
|
// expects a null-terminated string.
|
|
|
|
char nullz[64];
|
|
|
|
ptrdiff_t len = d->ptr - start;
|
|
|
|
if (len > (ptrdiff_t)(sizeof(nullz) - 1)) {
|
|
|
|
jsondec_err(d, "excessively long number");
|
|
|
|
}
|
|
|
|
memcpy(nullz, start, len);
|
|
|
|
nullz[len] = '\0';
|
|
|
|
|
|
|
|
char* end;
|
|
|
|
double val = strtod(nullz, &end);
|
|
|
|
UPB_ASSERT(end - nullz == len);
|
|
|
|
|
|
|
|
/* Currently the min/max-val conformance tests fail if we check this. Does
|
|
|
|
* this mean the conformance tests are wrong or strtod() is wrong, or
|
|
|
|
* something else? Investigate further. */
|
|
|
|
/*
|
|
|
|
if (errno == ERANGE) {
|
|
|
|
jsondec_err(d, "Number out of range");
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (val > DBL_MAX || val < -DBL_MAX) {
|
|
|
|
jsondec_err(d, "Number out of range");
|
|
|
|
}
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* JSON string ****************************************************************/
|
|
|
|
|
|
|
|
static char jsondec_escape(jsondec* d) {
|
|
|
|
switch (*d->ptr++) {
|
|
|
|
case '"':
|
|
|
|
return '\"';
|
|
|
|
case '\\':
|
|
|
|
return '\\';
|
|
|
|
case '/':
|
|
|
|
return '/';
|
|
|
|
case 'b':
|
|
|
|
return '\b';
|
|
|
|
case 'f':
|
|
|
|
return '\f';
|
|
|
|
case 'n':
|
|
|
|
return '\n';
|
|
|
|
case 'r':
|
|
|
|
return '\r';
|
|
|
|
case 't':
|
|
|
|
return '\t';
|
|
|
|
default:
|
|
|
|
jsondec_err(d, "Invalid escape char");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t jsondec_codepoint(jsondec* d) {
|
|
|
|
uint32_t cp = 0;
|
|
|
|
const char* end;
|
|
|
|
|
|
|
|
if (d->end - d->ptr < 4) {
|
|
|
|
jsondec_err(d, "EOF inside string");
|
|
|
|
}
|
|
|
|
|
|
|
|
end = d->ptr + 4;
|
|
|
|
while (d->ptr < end) {
|
|
|
|
char ch = *d->ptr++;
|
|
|
|
if (ch >= '0' && ch <= '9') {
|
|
|
|
ch -= '0';
|
|
|
|
} else if (ch >= 'a' && ch <= 'f') {
|
|
|
|
ch = ch - 'a' + 10;
|
|
|
|
} else if (ch >= 'A' && ch <= 'F') {
|
|
|
|
ch = ch - 'A' + 10;
|
|
|
|
} else {
|
|
|
|
jsondec_err(d, "Invalid hex digit");
|
|
|
|
}
|
|
|
|
cp = (cp << 4) | ch;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Parses a \uXXXX unicode escape (possibly a surrogate pair). */
|
|
|
|
static size_t jsondec_unicode(jsondec* d, char* out) {
|
|
|
|
uint32_t cp = jsondec_codepoint(d);
|
|
|
|
if (upb_Unicode_IsHigh(cp)) {
|
|
|
|
/* Surrogate pair: two 16-bit codepoints become a 32-bit codepoint. */
|
|
|
|
jsondec_parselit(d, "\\u");
|
|
|
|
uint32_t low = jsondec_codepoint(d);
|
|
|
|
if (!upb_Unicode_IsLow(low)) jsondec_err(d, "Invalid low surrogate");
|
|
|
|
cp = upb_Unicode_FromPair(cp, low);
|
|
|
|
} else if (upb_Unicode_IsLow(cp)) {
|
|
|
|
jsondec_err(d, "Unpaired low surrogate");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write to UTF-8 */
|
|
|
|
int bytes = upb_Unicode_ToUTF8(cp, out);
|
|
|
|
if (bytes == 0) jsondec_err(d, "Invalid codepoint");
|
|
|
|
return bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_resize(jsondec* d, char** buf, char** end, char** buf_end) {
|
|
|
|
size_t oldsize = *buf_end - *buf;
|
|
|
|
size_t len = *end - *buf;
|
|
|
|
size_t size = UPB_MAX(8, 2 * oldsize);
|
|
|
|
|
|
|
|
*buf = upb_Arena_Realloc(d->arena, *buf, len, size);
|
|
|
|
if (!*buf) jsondec_err(d, "Out of memory");
|
|
|
|
|
|
|
|
*end = *buf + len;
|
|
|
|
*buf_end = *buf + size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static upb_StringView jsondec_string(jsondec* d) {
|
|
|
|
char* buf = NULL;
|
|
|
|
char* end = NULL;
|
|
|
|
char* buf_end = NULL;
|
|
|
|
|
|
|
|
jsondec_skipws(d);
|
|
|
|
|
|
|
|
if (*d->ptr++ != '"') {
|
|
|
|
jsondec_err(d, "Expected string");
|
|
|
|
}
|
|
|
|
|
|
|
|
while (d->ptr < d->end) {
|
|
|
|
char ch = *d->ptr++;
|
|
|
|
|
|
|
|
if (end == buf_end) {
|
|
|
|
jsondec_resize(d, &buf, &end, &buf_end);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (ch) {
|
|
|
|
case '"': {
|
|
|
|
upb_StringView ret;
|
|
|
|
ret.data = buf;
|
|
|
|
ret.size = end - buf;
|
|
|
|
*end = '\0'; /* Needed for possible strtod(). */
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
case '\\':
|
|
|
|
if (d->ptr == d->end) goto eof;
|
|
|
|
if (*d->ptr == 'u') {
|
|
|
|
d->ptr++;
|
|
|
|
if (buf_end - end < 4) {
|
|
|
|
/* Allow space for maximum-sized codepoint (4 bytes). */
|
|
|
|
jsondec_resize(d, &buf, &end, &buf_end);
|
|
|
|
}
|
|
|
|
end += jsondec_unicode(d, end);
|
|
|
|
} else {
|
|
|
|
*end++ = jsondec_escape(d);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if ((unsigned char)ch < 0x20) {
|
|
|
|
jsondec_err(d, "Invalid char in JSON string");
|
|
|
|
}
|
|
|
|
*end++ = ch;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
eof:
|
|
|
|
jsondec_err(d, "EOF inside string");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_skipval(jsondec* d) {
|
|
|
|
switch (jsondec_peek(d)) {
|
|
|
|
case JD_OBJECT:
|
|
|
|
jsondec_objstart(d);
|
|
|
|
while (jsondec_objnext(d)) {
|
|
|
|
jsondec_string(d);
|
|
|
|
jsondec_entrysep(d);
|
|
|
|
jsondec_skipval(d);
|
|
|
|
}
|
|
|
|
jsondec_objend(d);
|
|
|
|
break;
|
|
|
|
case JD_ARRAY:
|
|
|
|
jsondec_arrstart(d);
|
|
|
|
while (jsondec_arrnext(d)) {
|
|
|
|
jsondec_skipval(d);
|
|
|
|
}
|
|
|
|
jsondec_arrend(d);
|
|
|
|
break;
|
|
|
|
case JD_TRUE:
|
|
|
|
jsondec_true(d);
|
|
|
|
break;
|
|
|
|
case JD_FALSE:
|
|
|
|
jsondec_false(d);
|
|
|
|
break;
|
|
|
|
case JD_NULL:
|
|
|
|
jsondec_null(d);
|
|
|
|
break;
|
|
|
|
case JD_STRING:
|
|
|
|
jsondec_string(d);
|
|
|
|
break;
|
|
|
|
case JD_NUMBER:
|
|
|
|
jsondec_number(d);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Base64 decoding for bytes fields. ******************************************/
|
|
|
|
|
|
|
|
static unsigned int jsondec_base64_tablelookup(const char ch) {
|
|
|
|
/* Table includes the normal base64 chars plus the URL-safe variant. */
|
|
|
|
const signed char table[256] = {
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, 62 /*+*/, -1, 62 /*-*/, -1, 63 /*/ */, 52 /*0*/,
|
|
|
|
53 /*1*/, 54 /*2*/, 55 /*3*/, 56 /*4*/, 57 /*5*/, 58 /*6*/, 59 /*7*/,
|
|
|
|
60 /*8*/, 61 /*9*/, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, 0 /*A*/, 1 /*B*/, 2 /*C*/, 3 /*D*/, 4 /*E*/,
|
|
|
|
5 /*F*/, 6 /*G*/, 07 /*H*/, 8 /*I*/, 9 /*J*/, 10 /*K*/, 11 /*L*/,
|
|
|
|
12 /*M*/, 13 /*N*/, 14 /*O*/, 15 /*P*/, 16 /*Q*/, 17 /*R*/, 18 /*S*/,
|
|
|
|
19 /*T*/, 20 /*U*/, 21 /*V*/, 22 /*W*/, 23 /*X*/, 24 /*Y*/, 25 /*Z*/,
|
|
|
|
-1, -1, -1, -1, 63 /*_*/, -1, 26 /*a*/,
|
|
|
|
27 /*b*/, 28 /*c*/, 29 /*d*/, 30 /*e*/, 31 /*f*/, 32 /*g*/, 33 /*h*/,
|
|
|
|
34 /*i*/, 35 /*j*/, 36 /*k*/, 37 /*l*/, 38 /*m*/, 39 /*n*/, 40 /*o*/,
|
|
|
|
41 /*p*/, 42 /*q*/, 43 /*r*/, 44 /*s*/, 45 /*t*/, 46 /*u*/, 47 /*v*/,
|
|
|
|
48 /*w*/, 49 /*x*/, 50 /*y*/, 51 /*z*/, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1, -1, -1, -1,
|
|
|
|
-1, -1, -1, -1};
|
|
|
|
|
|
|
|
/* Sign-extend return value so high bit will be set on any unexpected char. */
|
|
|
|
return table[(unsigned)ch];
|
|
|
|
}
|
|
|
|
|
|
|
|
static char* jsondec_partialbase64(jsondec* d, const char* ptr, const char* end,
|
|
|
|
char* out) {
|
|
|
|
int32_t val = -1;
|
|
|
|
|
|
|
|
switch (end - ptr) {
|
|
|
|
case 2:
|
|
|
|
val = jsondec_base64_tablelookup(ptr[0]) << 18 |
|
|
|
|
jsondec_base64_tablelookup(ptr[1]) << 12;
|
|
|
|
out[0] = val >> 16;
|
|
|
|
out += 1;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
val = jsondec_base64_tablelookup(ptr[0]) << 18 |
|
|
|
|
jsondec_base64_tablelookup(ptr[1]) << 12 |
|
|
|
|
jsondec_base64_tablelookup(ptr[2]) << 6;
|
|
|
|
out[0] = val >> 16;
|
|
|
|
out[1] = (val >> 8) & 0xff;
|
|
|
|
out += 2;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (val < 0) {
|
|
|
|
jsondec_err(d, "Corrupt base64");
|
|
|
|
}
|
|
|
|
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t jsondec_base64(jsondec* d, upb_StringView str) {
|
|
|
|
/* We decode in place. This is safe because this is a new buffer (not
|
|
|
|
* aliasing the input) and because base64 decoding shrinks 4 bytes into 3. */
|
|
|
|
char* out = (char*)str.data;
|
|
|
|
const char* ptr = str.data;
|
|
|
|
const char* end = ptr + str.size;
|
|
|
|
const char* end4 = ptr + (str.size & -4); /* Round down to multiple of 4. */
|
|
|
|
|
|
|
|
for (; ptr < end4; ptr += 4, out += 3) {
|
|
|
|
int val = jsondec_base64_tablelookup(ptr[0]) << 18 |
|
|
|
|
jsondec_base64_tablelookup(ptr[1]) << 12 |
|
|
|
|
jsondec_base64_tablelookup(ptr[2]) << 6 |
|
|
|
|
jsondec_base64_tablelookup(ptr[3]) << 0;
|
|
|
|
|
|
|
|
if (val < 0) {
|
|
|
|
/* Junk chars or padding. Remove trailing padding, if any. */
|
|
|
|
if (end - ptr == 4 && ptr[3] == '=') {
|
|
|
|
if (ptr[2] == '=') {
|
|
|
|
end -= 2;
|
|
|
|
} else {
|
|
|
|
end -= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
out[0] = val >> 16;
|
|
|
|
out[1] = (val >> 8) & 0xff;
|
|
|
|
out[2] = val & 0xff;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ptr < end) {
|
|
|
|
/* Process remaining chars. We do not require padding. */
|
|
|
|
out = jsondec_partialbase64(d, ptr, end, out);
|
|
|
|
}
|
|
|
|
|
|
|
|
return out - str.data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Low-level integer parsing **************************************************/
|
|
|
|
|
|
|
|
static const char* jsondec_buftouint64(jsondec* d, const char* ptr,
|
|
|
|
const char* end, uint64_t* val) {
|
|
|
|
const char* out = upb_BufToUint64(ptr, end, val);
|
|
|
|
if (!out) jsondec_err(d, "Integer overflow");
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char* jsondec_buftoint64(jsondec* d, const char* ptr,
|
|
|
|
const char* end, int64_t* val,
|
|
|
|
bool* is_neg) {
|
|
|
|
const char* out = upb_BufToInt64(ptr, end, val, is_neg);
|
|
|
|
if (!out) jsondec_err(d, "Integer overflow");
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint64_t jsondec_strtouint64(jsondec* d, upb_StringView str) {
|
|
|
|
const char* end = str.data + str.size;
|
|
|
|
uint64_t ret;
|
|
|
|
if (jsondec_buftouint64(d, str.data, end, &ret) != end) {
|
|
|
|
jsondec_err(d, "Non-number characters in quoted integer");
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t jsondec_strtoint64(jsondec* d, upb_StringView str) {
|
|
|
|
const char* end = str.data + str.size;
|
|
|
|
int64_t ret;
|
|
|
|
if (jsondec_buftoint64(d, str.data, end, &ret, NULL) != end) {
|
|
|
|
jsondec_err(d, "Non-number characters in quoted integer");
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_checkempty(jsondec* d, upb_StringView str,
|
|
|
|
const upb_FieldDef* f) {
|
|
|
|
if (str.size != 0) return;
|
|
|
|
d->result = kUpb_JsonDecodeResult_OkWithEmptyStringNumerics;
|
|
|
|
upb_Status_SetErrorFormat(d->status,
|
|
|
|
"Empty string is not a valid number (field: %s). "
|
|
|
|
"This will be an error in a future version.",
|
|
|
|
upb_FieldDef_FullName(f));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Primitive value types ******************************************************/
|
|
|
|
|
|
|
|
/* Parse INT32 or INT64 value. */
|
|
|
|
static upb_MessageValue jsondec_int(jsondec* d, const upb_FieldDef* f) {
|
|
|
|
upb_MessageValue val;
|
|
|
|
|
|
|
|
switch (jsondec_peek(d)) {
|
|
|
|
case JD_NUMBER: {
|
|
|
|
double dbl = jsondec_number(d);
|
|
|
|
if (dbl > 9223372036854774784.0 || dbl < -9223372036854775808.0) {
|
|
|
|
jsondec_err(d, "JSON number is out of range.");
|
|
|
|
}
|
|
|
|
val.int64_val = dbl; /* must be guarded, overflow here is UB */
|
|
|
|
if (val.int64_val != dbl) {
|
|
|
|
jsondec_errf(d, "JSON number was not integral (%f != %" PRId64 ")", dbl,
|
|
|
|
val.int64_val);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case JD_STRING: {
|
|
|
|
upb_StringView str = jsondec_string(d);
|
|
|
|
jsondec_checkempty(d, str, f);
|
|
|
|
val.int64_val = jsondec_strtoint64(d, str);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
jsondec_err(d, "Expected number or string");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (upb_FieldDef_CType(f) == kUpb_CType_Int32 ||
|
|
|
|
upb_FieldDef_CType(f) == kUpb_CType_Enum) {
|
|
|
|
if (val.int64_val > INT32_MAX || val.int64_val < INT32_MIN) {
|
|
|
|
jsondec_err(d, "Integer out of range.");
|
|
|
|
}
|
|
|
|
val.int32_val = (int32_t)val.int64_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Parse UINT32 or UINT64 value. */
|
|
|
|
static upb_MessageValue jsondec_uint(jsondec* d, const upb_FieldDef* f) {
|
|
|
|
upb_MessageValue val;
|
|
|
|
|
|
|
|
switch (jsondec_peek(d)) {
|
|
|
|
case JD_NUMBER: {
|
|
|
|
double dbl = jsondec_number(d);
|
|
|
|
if (dbl > 18446744073709549568.0 || dbl < 0) {
|
|
|
|
jsondec_err(d, "JSON number is out of range.");
|
|
|
|
}
|
|
|
|
val.uint64_val = dbl; /* must be guarded, overflow here is UB */
|
|
|
|
if (val.uint64_val != dbl) {
|
|
|
|
jsondec_errf(d, "JSON number was not integral (%f != %" PRIu64 ")", dbl,
|
|
|
|
val.uint64_val);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case JD_STRING: {
|
|
|
|
upb_StringView str = jsondec_string(d);
|
|
|
|
jsondec_checkempty(d, str, f);
|
|
|
|
val.uint64_val = jsondec_strtouint64(d, str);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
jsondec_err(d, "Expected number or string");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (upb_FieldDef_CType(f) == kUpb_CType_UInt32) {
|
|
|
|
if (val.uint64_val > UINT32_MAX) {
|
|
|
|
jsondec_err(d, "Integer out of range.");
|
|
|
|
}
|
|
|
|
val.uint32_val = (uint32_t)val.uint64_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Parse DOUBLE or FLOAT value. */
|
|
|
|
static upb_MessageValue jsondec_double(jsondec* d, const upb_FieldDef* f) {
|
|
|
|
upb_StringView str;
|
|
|
|
upb_MessageValue val;
|
|
|
|
|
|
|
|
switch (jsondec_peek(d)) {
|
|
|
|
case JD_NUMBER:
|
|
|
|
val.double_val = jsondec_number(d);
|
|
|
|
break;
|
|
|
|
case JD_STRING:
|
|
|
|
str = jsondec_string(d);
|
|
|
|
if (str.size == 0) {
|
|
|
|
jsondec_checkempty(d, str, f);
|
|
|
|
val.double_val = 0.0;
|
|
|
|
} else if (jsondec_streql(str, "NaN")) {
|
|
|
|
val.double_val = NAN;
|
|
|
|
} else if (jsondec_streql(str, "Infinity")) {
|
|
|
|
val.double_val = INFINITY;
|
|
|
|
} else if (jsondec_streql(str, "-Infinity")) {
|
|
|
|
val.double_val = -INFINITY;
|
|
|
|
} else {
|
|
|
|
char* end;
|
|
|
|
val.double_val = strtod(str.data, &end);
|
|
|
|
if (end != str.data + str.size) {
|
|
|
|
d->result = kUpb_JsonDecodeResult_OkWithEmptyStringNumerics;
|
|
|
|
upb_Status_SetErrorFormat(
|
|
|
|
d->status,
|
|
|
|
"Non-number characters in quoted number (field: %s). "
|
|
|
|
"This will be an error in a future version.",
|
|
|
|
upb_FieldDef_FullName(f));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
jsondec_err(d, "Expected number or string");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (upb_FieldDef_CType(f) == kUpb_CType_Float) {
|
|
|
|
float f = val.double_val;
|
|
|
|
if (val.double_val != INFINITY && val.double_val != -INFINITY) {
|
|
|
|
if (f == INFINITY || f == -INFINITY) jsondec_err(d, "Float out of range");
|
|
|
|
}
|
|
|
|
val.float_val = f;
|
|
|
|
}
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Parse STRING or BYTES value. */
|
|
|
|
static upb_MessageValue jsondec_strfield(jsondec* d, const upb_FieldDef* f) {
|
|
|
|
upb_MessageValue val;
|
|
|
|
val.str_val = jsondec_string(d);
|
|
|
|
if (upb_FieldDef_CType(f) == kUpb_CType_Bytes) {
|
|
|
|
val.str_val.size = jsondec_base64(d, val.str_val);
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static upb_JsonMessageValue jsondec_enum(jsondec* d, const upb_FieldDef* f) {
|
|
|
|
switch (jsondec_peek(d)) {
|
|
|
|
case JD_STRING: {
|
|
|
|
upb_StringView str = jsondec_string(d);
|
|
|
|
const upb_EnumDef* e = upb_FieldDef_EnumSubDef(f);
|
|
|
|
const upb_EnumValueDef* ev =
|
|
|
|
upb_EnumDef_FindValueByNameWithSize(e, str.data, str.size);
|
|
|
|
upb_JsonMessageValue val = {.ignore = false};
|
|
|
|
if (ev) {
|
|
|
|
val.value.int32_val = upb_EnumValueDef_Number(ev);
|
|
|
|
} else {
|
|
|
|
if (d->options & upb_JsonDecode_IgnoreUnknown) {
|
|
|
|
val.ignore = true;
|
|
|
|
} else {
|
|
|
|
jsondec_errf(d, "Unknown enumerator: '" UPB_STRINGVIEW_FORMAT "'",
|
|
|
|
UPB_STRINGVIEW_ARGS(str));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
case JD_NULL: {
|
|
|
|
if (jsondec_isnullvalue(f)) {
|
|
|
|
upb_JsonMessageValue val = {.ignore = false};
|
|
|
|
jsondec_null(d);
|
|
|
|
val.value.int32_val = 0;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Fallthrough. */
|
|
|
|
default:
|
|
|
|
return (upb_JsonMessageValue){.value = jsondec_int(d, f),
|
|
|
|
.ignore = false};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static upb_MessageValue jsondec_bool(jsondec* d, const upb_FieldDef* f) {
|
|
|
|
bool is_map_key = upb_FieldDef_Number(f) == 1 &&
|
|
|
|
upb_MessageDef_IsMapEntry(upb_FieldDef_ContainingType(f));
|
|
|
|
upb_MessageValue val;
|
|
|
|
|
|
|
|
if (is_map_key) {
|
|
|
|
upb_StringView str = jsondec_string(d);
|
|
|
|
if (jsondec_streql(str, "true")) {
|
|
|
|
val.bool_val = true;
|
|
|
|
} else if (jsondec_streql(str, "false")) {
|
|
|
|
val.bool_val = false;
|
|
|
|
} else {
|
|
|
|
jsondec_err(d, "Invalid boolean map key");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
switch (jsondec_peek(d)) {
|
|
|
|
case JD_TRUE:
|
|
|
|
val.bool_val = true;
|
|
|
|
jsondec_true(d);
|
|
|
|
break;
|
|
|
|
case JD_FALSE:
|
|
|
|
val.bool_val = false;
|
|
|
|
jsondec_false(d);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
jsondec_err(d, "Expected true or false");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Composite types (array/message/map) ****************************************/
|
|
|
|
|
|
|
|
static void jsondec_array(jsondec* d, upb_Message* msg, const upb_FieldDef* f) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
upb_Array* arr = upb_Message_Mutable(msg, f, d->arena).array;
|
|
|
|
|
|
|
|
jsondec_arrstart(d);
|
|
|
|
while (jsondec_arrnext(d)) {
|
|
|
|
upb_JsonMessageValue elem = jsondec_value(d, f);
|
|
|
|
if (!elem.ignore) {
|
|
|
|
upb_Array_Append(arr, elem.value, d->arena);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
jsondec_arrend(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_map(jsondec* d, upb_Message* msg, const upb_FieldDef* f) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
upb_Map* map = upb_Message_Mutable(msg, f, d->arena).map;
|
|
|
|
const upb_MessageDef* entry = upb_FieldDef_MessageSubDef(f);
|
|
|
|
const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry, 1);
|
|
|
|
const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry, 2);
|
|
|
|
|
|
|
|
jsondec_objstart(d);
|
|
|
|
while (jsondec_objnext(d)) {
|
|
|
|
upb_JsonMessageValue key, val;
|
|
|
|
key = jsondec_value(d, key_f);
|
|
|
|
UPB_ASSUME(!key.ignore); // Map key cannot be enum.
|
|
|
|
jsondec_entrysep(d);
|
|
|
|
val = jsondec_value(d, val_f);
|
|
|
|
if (!val.ignore) {
|
|
|
|
upb_Map_Set(map, key.value, val.value, d->arena);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
jsondec_objend(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_tomsg(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
if (upb_MessageDef_WellKnownType(m) == kUpb_WellKnown_Unspecified) {
|
|
|
|
jsondec_object(d, msg, m);
|
|
|
|
} else {
|
|
|
|
jsondec_wellknown(d, msg, m);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static upb_MessageValue jsondec_msg(jsondec* d, const upb_FieldDef* f) {
|
|
|
|
const upb_MessageDef* m = upb_FieldDef_MessageSubDef(f);
|
|
|
|
const upb_MiniTable* layout = upb_MessageDef_MiniTable(m);
|
|
|
|
upb_Message* msg = upb_Message_New(layout, d->arena);
|
|
|
|
upb_MessageValue val;
|
|
|
|
|
|
|
|
jsondec_tomsg(d, msg, m);
|
|
|
|
val.msg_val = msg;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_field(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
upb_StringView name;
|
|
|
|
const upb_FieldDef* f;
|
|
|
|
const upb_FieldDef* preserved;
|
|
|
|
|
|
|
|
name = jsondec_string(d);
|
|
|
|
jsondec_entrysep(d);
|
|
|
|
|
|
|
|
if (name.size >= 2 && name.data[0] == '[' &&
|
|
|
|
name.data[name.size - 1] == ']') {
|
|
|
|
f = upb_DefPool_FindExtensionByNameWithSize(d->symtab, name.data + 1,
|
|
|
|
name.size - 2);
|
|
|
|
if (f && upb_FieldDef_ContainingType(f) != m) {
|
|
|
|
jsondec_errf(
|
|
|
|
d, "Extension %s extends message %s, but was seen in message %s",
|
|
|
|
upb_FieldDef_FullName(f),
|
|
|
|
upb_MessageDef_FullName(upb_FieldDef_ContainingType(f)),
|
|
|
|
upb_MessageDef_FullName(m));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
f = upb_MessageDef_FindByJsonNameWithSize(m, name.data, name.size);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!f) {
|
|
|
|
if ((d->options & upb_JsonDecode_IgnoreUnknown) == 0) {
|
|
|
|
jsondec_errf(d, "No such field: " UPB_STRINGVIEW_FORMAT,
|
|
|
|
UPB_STRINGVIEW_ARGS(name));
|
|
|
|
}
|
|
|
|
jsondec_skipval(d);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (jsondec_peek(d) == JD_NULL && !jsondec_isvalue(f)) {
|
|
|
|
/* JSON "null" indicates a default value, so no need to set anything. */
|
|
|
|
jsondec_null(d);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (upb_FieldDef_RealContainingOneof(f) &&
|
|
|
|
upb_Message_WhichOneofByDef(msg, upb_FieldDef_ContainingOneof(f))) {
|
|
|
|
jsondec_err(d, "More than one field for this oneof.");
|
|
|
|
}
|
|
|
|
|
|
|
|
preserved = d->debug_field;
|
|
|
|
d->debug_field = f;
|
|
|
|
|
|
|
|
if (upb_FieldDef_IsMap(f)) {
|
|
|
|
jsondec_map(d, msg, f);
|
|
|
|
} else if (upb_FieldDef_IsRepeated(f)) {
|
|
|
|
jsondec_array(d, msg, f);
|
|
|
|
} else if (upb_FieldDef_IsSubMessage(f)) {
|
|
|
|
upb_Message* submsg = upb_Message_Mutable(msg, f, d->arena).msg;
|
|
|
|
const upb_MessageDef* subm = upb_FieldDef_MessageSubDef(f);
|
|
|
|
jsondec_tomsg(d, submsg, subm);
|
|
|
|
} else {
|
|
|
|
upb_JsonMessageValue val = jsondec_value(d, f);
|
|
|
|
if (!val.ignore) {
|
|
|
|
upb_Message_SetFieldByDef(msg, f, val.value, d->arena);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
d->debug_field = preserved;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_object(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
jsondec_objstart(d);
|
|
|
|
while (jsondec_objnext(d)) {
|
|
|
|
jsondec_field(d, msg, m);
|
|
|
|
}
|
|
|
|
jsondec_objend(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
static upb_MessageValue jsondec_nonenum(jsondec* d, const upb_FieldDef* f) {
|
|
|
|
switch (upb_FieldDef_CType(f)) {
|
|
|
|
case kUpb_CType_Bool:
|
|
|
|
return jsondec_bool(d, f);
|
|
|
|
case kUpb_CType_Float:
|
|
|
|
case kUpb_CType_Double:
|
|
|
|
return jsondec_double(d, f);
|
|
|
|
case kUpb_CType_UInt32:
|
|
|
|
case kUpb_CType_UInt64:
|
|
|
|
return jsondec_uint(d, f);
|
|
|
|
case kUpb_CType_Int32:
|
|
|
|
case kUpb_CType_Int64:
|
|
|
|
return jsondec_int(d, f);
|
|
|
|
case kUpb_CType_String:
|
|
|
|
case kUpb_CType_Bytes:
|
|
|
|
return jsondec_strfield(d, f);
|
|
|
|
case kUpb_CType_Message:
|
|
|
|
return jsondec_msg(d, f);
|
|
|
|
case kUpb_CType_Enum:
|
|
|
|
default:
|
|
|
|
UPB_UNREACHABLE();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static upb_JsonMessageValue jsondec_value(jsondec* d, const upb_FieldDef* f) {
|
|
|
|
if (upb_FieldDef_CType(f) == kUpb_CType_Enum) {
|
|
|
|
return jsondec_enum(d, f);
|
|
|
|
} else {
|
|
|
|
return (upb_JsonMessageValue){.value = jsondec_nonenum(d, f),
|
|
|
|
.ignore = false};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Well-known types ***********************************************************/
|
|
|
|
|
|
|
|
static int jsondec_tsdigits(jsondec* d, const char** ptr, size_t digits,
|
|
|
|
const char* after) {
|
|
|
|
uint64_t val;
|
|
|
|
const char* p = *ptr;
|
|
|
|
const char* end = p + digits;
|
|
|
|
size_t after_len = after ? strlen(after) : 0;
|
|
|
|
|
|
|
|
UPB_ASSERT(digits <= 9); /* int can't overflow. */
|
|
|
|
|
|
|
|
if (jsondec_buftouint64(d, p, end, &val) != end ||
|
|
|
|
(after_len && memcmp(end, after, after_len) != 0)) {
|
|
|
|
jsondec_err(d, "Malformed timestamp");
|
|
|
|
}
|
|
|
|
|
|
|
|
UPB_ASSERT(val < INT_MAX);
|
|
|
|
|
|
|
|
*ptr = end + after_len;
|
|
|
|
return (int)val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int jsondec_nanos(jsondec* d, const char** ptr, const char* end) {
|
|
|
|
uint64_t nanos = 0;
|
|
|
|
const char* p = *ptr;
|
|
|
|
|
|
|
|
if (p != end && *p == '.') {
|
|
|
|
const char* nano_end = jsondec_buftouint64(d, p + 1, end, &nanos);
|
|
|
|
int digits = (int)(nano_end - p - 1);
|
|
|
|
int exp_lg10 = 9 - digits;
|
|
|
|
if (digits > 9) {
|
|
|
|
jsondec_err(d, "Too many digits for partial seconds");
|
|
|
|
}
|
|
|
|
while (exp_lg10--) nanos *= 10;
|
|
|
|
*ptr = nano_end;
|
|
|
|
}
|
|
|
|
|
|
|
|
UPB_ASSERT(nanos < INT_MAX);
|
|
|
|
|
|
|
|
return (int)nanos;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* jsondec_epochdays(1970, 1, 1) == 1970-01-01 == 0. */
|
|
|
|
int jsondec_epochdays(int y, int m, int d) {
|
|
|
|
const uint32_t year_base = 4800; /* Before min year, multiple of 400. */
|
|
|
|
const uint32_t m_adj = m - 3; /* March-based month. */
|
|
|
|
const uint32_t carry = m_adj > (uint32_t)m ? 1 : 0;
|
|
|
|
const uint32_t adjust = carry ? 12 : 0;
|
|
|
|
const uint32_t y_adj = y + year_base - carry;
|
|
|
|
const uint32_t month_days = ((m_adj + adjust) * 62719 + 769) / 2048;
|
|
|
|
const uint32_t leap_days = y_adj / 4 - y_adj / 100 + y_adj / 400;
|
|
|
|
return y_adj * 365 + leap_days + month_days + (d - 1) - 2472632;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t jsondec_unixtime(int y, int m, int d, int h, int min, int s) {
|
|
|
|
return (int64_t)jsondec_epochdays(y, m, d) * 86400 + h * 3600 + min * 60 + s;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_timestamp(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
upb_MessageValue seconds;
|
|
|
|
upb_MessageValue nanos;
|
|
|
|
upb_StringView str = jsondec_string(d);
|
|
|
|
const char* ptr = str.data;
|
|
|
|
const char* end = ptr + str.size;
|
|
|
|
|
|
|
|
if (str.size < 20) goto malformed;
|
|
|
|
|
|
|
|
{
|
|
|
|
/* 1972-01-01T01:00:00 */
|
|
|
|
int year = jsondec_tsdigits(d, &ptr, 4, "-");
|
|
|
|
int mon = jsondec_tsdigits(d, &ptr, 2, "-");
|
|
|
|
int day = jsondec_tsdigits(d, &ptr, 2, "T");
|
|
|
|
int hour = jsondec_tsdigits(d, &ptr, 2, ":");
|
|
|
|
int min = jsondec_tsdigits(d, &ptr, 2, ":");
|
|
|
|
int sec = jsondec_tsdigits(d, &ptr, 2, NULL);
|
|
|
|
|
|
|
|
seconds.int64_val = jsondec_unixtime(year, mon, day, hour, min, sec);
|
|
|
|
}
|
|
|
|
|
|
|
|
nanos.int32_val = jsondec_nanos(d, &ptr, end);
|
|
|
|
|
|
|
|
{
|
|
|
|
/* [+-]08:00 or Z */
|
|
|
|
int ofs_hour = 0;
|
|
|
|
int ofs_min = 0;
|
|
|
|
bool neg = false;
|
|
|
|
|
|
|
|
if (ptr == end) goto malformed;
|
|
|
|
|
|
|
|
switch (*ptr++) {
|
|
|
|
case '-':
|
|
|
|
neg = true;
|
|
|
|
/* fallthrough */
|
|
|
|
case '+':
|
|
|
|
if ((end - ptr) != 5) goto malformed;
|
|
|
|
ofs_hour = jsondec_tsdigits(d, &ptr, 2, ":");
|
|
|
|
ofs_min = jsondec_tsdigits(d, &ptr, 2, NULL);
|
|
|
|
ofs_min = ((ofs_hour * 60) + ofs_min) * 60;
|
|
|
|
seconds.int64_val += (neg ? ofs_min : -ofs_min);
|
|
|
|
break;
|
|
|
|
case 'Z':
|
|
|
|
if (ptr != end) goto malformed;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto malformed;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (seconds.int64_val < -62135596800) {
|
|
|
|
jsondec_err(d, "Timestamp out of range");
|
|
|
|
}
|
|
|
|
|
|
|
|
upb_Message_SetFieldByDef(msg, upb_MessageDef_FindFieldByNumber(m, 1),
|
|
|
|
seconds, d->arena);
|
|
|
|
upb_Message_SetFieldByDef(msg, upb_MessageDef_FindFieldByNumber(m, 2), nanos,
|
|
|
|
d->arena);
|
|
|
|
return;
|
|
|
|
|
|
|
|
malformed:
|
|
|
|
jsondec_err(d, "Malformed timestamp");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_duration(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
upb_MessageValue seconds;
|
|
|
|
upb_MessageValue nanos;
|
|
|
|
upb_StringView str = jsondec_string(d);
|
|
|
|
const char* ptr = str.data;
|
|
|
|
const char* end = ptr + str.size;
|
|
|
|
const int64_t max = (uint64_t)3652500 * 86400;
|
|
|
|
bool neg = false;
|
|
|
|
|
|
|
|
/* "3.000000001s", "3s", etc. */
|
|
|
|
ptr = jsondec_buftoint64(d, ptr, end, &seconds.int64_val, &neg);
|
|
|
|
nanos.int32_val = jsondec_nanos(d, &ptr, end);
|
|
|
|
|
|
|
|
if (end - ptr != 1 || *ptr != 's') {
|
|
|
|
jsondec_err(d, "Malformed duration");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (seconds.int64_val < -max || seconds.int64_val > max) {
|
|
|
|
jsondec_err(d, "Duration out of range");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (neg) {
|
|
|
|
nanos.int32_val = -nanos.int32_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
upb_Message_SetFieldByDef(msg, upb_MessageDef_FindFieldByNumber(m, 1),
|
|
|
|
seconds, d->arena);
|
|
|
|
upb_Message_SetFieldByDef(msg, upb_MessageDef_FindFieldByNumber(m, 2), nanos,
|
|
|
|
d->arena);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_listvalue(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
const upb_FieldDef* values_f = upb_MessageDef_FindFieldByNumber(m, 1);
|
|
|
|
const upb_MessageDef* value_m = upb_FieldDef_MessageSubDef(values_f);
|
|
|
|
const upb_MiniTable* value_layout = upb_MessageDef_MiniTable(value_m);
|
|
|
|
upb_Array* values = upb_Message_Mutable(msg, values_f, d->arena).array;
|
|
|
|
|
|
|
|
jsondec_arrstart(d);
|
|
|
|
while (jsondec_arrnext(d)) {
|
|
|
|
upb_Message* value_msg = upb_Message_New(value_layout, d->arena);
|
|
|
|
upb_MessageValue value;
|
|
|
|
value.msg_val = value_msg;
|
|
|
|
upb_Array_Append(values, value, d->arena);
|
|
|
|
jsondec_wellknownvalue(d, value_msg, value_m);
|
|
|
|
}
|
|
|
|
jsondec_arrend(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_struct(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
const upb_FieldDef* fields_f = upb_MessageDef_FindFieldByNumber(m, 1);
|
|
|
|
const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(fields_f);
|
|
|
|
const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(entry_m, 2);
|
|
|
|
const upb_MessageDef* value_m = upb_FieldDef_MessageSubDef(value_f);
|
|
|
|
const upb_MiniTable* value_layout = upb_MessageDef_MiniTable(value_m);
|
|
|
|
upb_Map* fields = upb_Message_Mutable(msg, fields_f, d->arena).map;
|
|
|
|
|
|
|
|
jsondec_objstart(d);
|
|
|
|
while (jsondec_objnext(d)) {
|
|
|
|
upb_MessageValue key, value;
|
|
|
|
upb_Message* value_msg = upb_Message_New(value_layout, d->arena);
|
|
|
|
key.str_val = jsondec_string(d);
|
|
|
|
value.msg_val = value_msg;
|
|
|
|
upb_Map_Set(fields, key, value, d->arena);
|
|
|
|
jsondec_entrysep(d);
|
|
|
|
jsondec_wellknownvalue(d, value_msg, value_m);
|
|
|
|
}
|
|
|
|
jsondec_objend(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_wellknownvalue(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
upb_MessageValue val;
|
|
|
|
const upb_FieldDef* f;
|
|
|
|
upb_Message* submsg;
|
|
|
|
|
|
|
|
switch (jsondec_peek(d)) {
|
|
|
|
case JD_NUMBER:
|
|
|
|
/* double number_value = 2; */
|
|
|
|
f = upb_MessageDef_FindFieldByNumber(m, 2);
|
|
|
|
val.double_val = jsondec_number(d);
|
|
|
|
break;
|
|
|
|
case JD_STRING:
|
|
|
|
/* string string_value = 3; */
|
|
|
|
f = upb_MessageDef_FindFieldByNumber(m, 3);
|
|
|
|
val.str_val = jsondec_string(d);
|
|
|
|
break;
|
|
|
|
case JD_FALSE:
|
|
|
|
/* bool bool_value = 4; */
|
|
|
|
f = upb_MessageDef_FindFieldByNumber(m, 4);
|
|
|
|
val.bool_val = false;
|
|
|
|
jsondec_false(d);
|
|
|
|
break;
|
|
|
|
case JD_TRUE:
|
|
|
|
/* bool bool_value = 4; */
|
|
|
|
f = upb_MessageDef_FindFieldByNumber(m, 4);
|
|
|
|
val.bool_val = true;
|
|
|
|
jsondec_true(d);
|
|
|
|
break;
|
|
|
|
case JD_NULL:
|
|
|
|
/* NullValue null_value = 1; */
|
|
|
|
f = upb_MessageDef_FindFieldByNumber(m, 1);
|
|
|
|
val.int32_val = 0;
|
|
|
|
jsondec_null(d);
|
|
|
|
break;
|
|
|
|
/* Note: these cases return, because upb_Message_Mutable() is enough. */
|
|
|
|
case JD_OBJECT:
|
|
|
|
/* Struct struct_value = 5; */
|
|
|
|
f = upb_MessageDef_FindFieldByNumber(m, 5);
|
|
|
|
submsg = upb_Message_Mutable(msg, f, d->arena).msg;
|
|
|
|
jsondec_struct(d, submsg, upb_FieldDef_MessageSubDef(f));
|
|
|
|
return;
|
|
|
|
case JD_ARRAY:
|
|
|
|
/* ListValue list_value = 6; */
|
|
|
|
f = upb_MessageDef_FindFieldByNumber(m, 6);
|
|
|
|
submsg = upb_Message_Mutable(msg, f, d->arena).msg;
|
|
|
|
jsondec_listvalue(d, submsg, upb_FieldDef_MessageSubDef(f));
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
UPB_UNREACHABLE();
|
|
|
|
}
|
|
|
|
|
|
|
|
upb_Message_SetFieldByDef(msg, f, val, d->arena);
|
|
|
|
}
|
|
|
|
|
|
|
|
static upb_StringView jsondec_mask(jsondec* d, const char* buf,
|
|
|
|
const char* end) {
|
|
|
|
/* FieldMask fields grow due to inserted '_' characters, so we can't do the
|
|
|
|
* transform in place. */
|
|
|
|
const char* ptr = buf;
|
|
|
|
upb_StringView ret;
|
|
|
|
char* out;
|
|
|
|
|
|
|
|
ret.size = end - ptr;
|
|
|
|
while (ptr < end) {
|
|
|
|
ret.size += (*ptr >= 'A' && *ptr <= 'Z');
|
|
|
|
ptr++;
|
|
|
|
}
|
|
|
|
|
|
|
|
out = upb_Arena_Malloc(d->arena, ret.size);
|
|
|
|
ptr = buf;
|
|
|
|
ret.data = out;
|
|
|
|
|
|
|
|
while (ptr < end) {
|
|
|
|
char ch = *ptr++;
|
|
|
|
if (ch >= 'A' && ch <= 'Z') {
|
|
|
|
*out++ = '_';
|
|
|
|
*out++ = ch + 32;
|
|
|
|
} else if (ch == '_') {
|
|
|
|
jsondec_err(d, "field mask may not contain '_'");
|
|
|
|
} else {
|
|
|
|
*out++ = ch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_fieldmask(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
/* repeated string paths = 1; */
|
|
|
|
const upb_FieldDef* paths_f = upb_MessageDef_FindFieldByNumber(m, 1);
|
|
|
|
upb_Array* arr = upb_Message_Mutable(msg, paths_f, d->arena).array;
|
|
|
|
upb_StringView str = jsondec_string(d);
|
|
|
|
const char* ptr = str.data;
|
|
|
|
const char* end = ptr + str.size;
|
|
|
|
upb_MessageValue val;
|
|
|
|
|
|
|
|
while (ptr < end) {
|
|
|
|
const char* elem_end = memchr(ptr, ',', end - ptr);
|
|
|
|
if (elem_end) {
|
|
|
|
val.str_val = jsondec_mask(d, ptr, elem_end);
|
|
|
|
ptr = elem_end + 1;
|
|
|
|
} else {
|
|
|
|
val.str_val = jsondec_mask(d, ptr, end);
|
|
|
|
ptr = end;
|
|
|
|
}
|
|
|
|
upb_Array_Append(arr, val, d->arena);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_anyfield(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
if (upb_MessageDef_WellKnownType(m) == kUpb_WellKnown_Unspecified) {
|
|
|
|
/* For regular types: {"@type": "[user type]", "f1": <V1>, "f2": <V2>}
|
|
|
|
* where f1, f2, etc. are the normal fields of this type. */
|
|
|
|
jsondec_field(d, msg, m);
|
|
|
|
} else {
|
|
|
|
/* For well-known types: {"@type": "[well-known type]", "value": <X>}
|
|
|
|
* where <X> is whatever encoding the WKT normally uses. */
|
|
|
|
upb_StringView str = jsondec_string(d);
|
|
|
|
jsondec_entrysep(d);
|
|
|
|
if (!jsondec_streql(str, "value")) {
|
|
|
|
jsondec_err(d, "Key for well-known type must be 'value'");
|
|
|
|
}
|
|
|
|
jsondec_wellknown(d, msg, m);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const upb_MessageDef* jsondec_typeurl(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
const upb_FieldDef* type_url_f = upb_MessageDef_FindFieldByNumber(m, 1);
|
|
|
|
const upb_MessageDef* type_m;
|
|
|
|
upb_StringView type_url = jsondec_string(d);
|
|
|
|
const char* end = type_url.data + type_url.size;
|
|
|
|
const char* ptr = end;
|
|
|
|
upb_MessageValue val;
|
|
|
|
|
|
|
|
val.str_val = type_url;
|
|
|
|
upb_Message_SetFieldByDef(msg, type_url_f, val, d->arena);
|
|
|
|
|
|
|
|
/* Find message name after the last '/' */
|
|
|
|
while (ptr > type_url.data && *--ptr != '/') {
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ptr == type_url.data || ptr == end) {
|
|
|
|
jsondec_err(d, "Type url must have at least one '/' and non-empty host");
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr++;
|
|
|
|
type_m = upb_DefPool_FindMessageByNameWithSize(d->symtab, ptr, end - ptr);
|
|
|
|
|
|
|
|
if (!type_m) {
|
|
|
|
jsondec_err(d, "Type was not found");
|
|
|
|
}
|
|
|
|
|
|
|
|
return type_m;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_any(jsondec* d, upb_Message* msg, const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
/* string type_url = 1;
|
|
|
|
* bytes value = 2; */
|
|
|
|
const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(m, 2);
|
|
|
|
upb_Message* any_msg;
|
|
|
|
const upb_MessageDef* any_m = NULL;
|
|
|
|
const char* pre_type_data = NULL;
|
|
|
|
const char* pre_type_end = NULL;
|
|
|
|
upb_MessageValue encoded;
|
|
|
|
|
|
|
|
jsondec_objstart(d);
|
|
|
|
|
|
|
|
/* Scan looking for "@type", which is not necessarily first. */
|
|
|
|
while (!any_m && jsondec_objnext(d)) {
|
|
|
|
const char* start = d->ptr;
|
|
|
|
upb_StringView name = jsondec_string(d);
|
|
|
|
jsondec_entrysep(d);
|
|
|
|
if (jsondec_streql(name, "@type")) {
|
|
|
|
any_m = jsondec_typeurl(d, msg, m);
|
|
|
|
if (pre_type_data) {
|
|
|
|
pre_type_end = start;
|
|
|
|
while (*pre_type_end != ',') pre_type_end--;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!pre_type_data) pre_type_data = start;
|
|
|
|
jsondec_skipval(d);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!any_m) {
|
|
|
|
jsondec_err(d, "Any object didn't contain a '@type' field");
|
|
|
|
}
|
|
|
|
|
|
|
|
const upb_MiniTable* any_layout = upb_MessageDef_MiniTable(any_m);
|
|
|
|
any_msg = upb_Message_New(any_layout, d->arena);
|
|
|
|
|
|
|
|
if (pre_type_data) {
|
|
|
|
size_t len = pre_type_end - pre_type_data + 1;
|
|
|
|
char* tmp = upb_Arena_Malloc(d->arena, len);
|
|
|
|
const char* saved_ptr = d->ptr;
|
|
|
|
const char* saved_end = d->end;
|
|
|
|
memcpy(tmp, pre_type_data, len - 1);
|
|
|
|
tmp[len - 1] = '}';
|
|
|
|
d->ptr = tmp;
|
|
|
|
d->end = tmp + len;
|
|
|
|
d->is_first = true;
|
|
|
|
while (jsondec_objnext(d)) {
|
|
|
|
jsondec_anyfield(d, any_msg, any_m);
|
|
|
|
}
|
|
|
|
d->ptr = saved_ptr;
|
|
|
|
d->end = saved_end;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (jsondec_objnext(d)) {
|
|
|
|
jsondec_anyfield(d, any_msg, any_m);
|
|
|
|
}
|
|
|
|
|
|
|
|
jsondec_objend(d);
|
|
|
|
|
|
|
|
upb_EncodeStatus status =
|
|
|
|
upb_Encode(any_msg, upb_MessageDef_MiniTable(any_m), 0, d->arena,
|
|
|
|
(char**)&encoded.str_val.data, &encoded.str_val.size);
|
|
|
|
// TODO: We should fail gracefully here on a bad return status.
|
|
|
|
UPB_ASSERT(status == kUpb_EncodeStatus_Ok);
|
|
|
|
upb_Message_SetFieldByDef(msg, value_f, encoded, d->arena);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_wrapper(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(m, 1);
|
|
|
|
upb_JsonMessageValue val = jsondec_value(d, value_f);
|
|
|
|
UPB_ASSUME(val.ignore == false); // Wrapper cannot be an enum.
|
|
|
|
upb_Message_SetFieldByDef(msg, value_f, val.value, d->arena);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void jsondec_wellknown(jsondec* d, upb_Message* msg,
|
|
|
|
const upb_MessageDef* m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
switch (upb_MessageDef_WellKnownType(m)) {
|
|
|
|
case kUpb_WellKnown_Any:
|
|
|
|
jsondec_any(d, msg, m);
|
|
|
|
break;
|
|
|
|
case kUpb_WellKnown_FieldMask:
|
|
|
|
jsondec_fieldmask(d, msg, m);
|
|
|
|
break;
|
|
|
|
case kUpb_WellKnown_Duration:
|
|
|
|
jsondec_duration(d, msg, m);
|
|
|
|
break;
|
|
|
|
case kUpb_WellKnown_Timestamp:
|
|
|
|
jsondec_timestamp(d, msg, m);
|
|
|
|
break;
|
|
|
|
case kUpb_WellKnown_Value:
|
|
|
|
jsondec_wellknownvalue(d, msg, m);
|
|
|
|
break;
|
|
|
|
case kUpb_WellKnown_ListValue:
|
|
|
|
jsondec_listvalue(d, msg, m);
|
|
|
|
break;
|
|
|
|
case kUpb_WellKnown_Struct:
|
|
|
|
jsondec_struct(d, msg, m);
|
|
|
|
break;
|
|
|
|
case kUpb_WellKnown_DoubleValue:
|
|
|
|
case kUpb_WellKnown_FloatValue:
|
|
|
|
case kUpb_WellKnown_Int64Value:
|
|
|
|
case kUpb_WellKnown_UInt64Value:
|
|
|
|
case kUpb_WellKnown_Int32Value:
|
|
|
|
case kUpb_WellKnown_UInt32Value:
|
|
|
|
case kUpb_WellKnown_StringValue:
|
|
|
|
case kUpb_WellKnown_BytesValue:
|
|
|
|
case kUpb_WellKnown_BoolValue:
|
|
|
|
jsondec_wrapper(d, msg, m);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
UPB_UNREACHABLE();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int upb_JsonDecoder_Decode(jsondec* const d, upb_Message* const msg,
|
|
|
|
const upb_MessageDef* const m) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
if (UPB_SETJMP(d->err)) return kUpb_JsonDecodeResult_Error;
|
|
|
|
|
|
|
|
jsondec_tomsg(d, msg, m);
|
|
|
|
|
|
|
|
// Consume any trailing whitespace before checking if we read the entire
|
|
|
|
// input.
|
|
|
|
jsondec_consumews(d);
|
|
|
|
|
|
|
|
if (d->ptr == d->end) {
|
|
|
|
return d->result;
|
|
|
|
} else {
|
|
|
|
jsondec_seterrmsg(d, "unexpected trailing characters");
|
|
|
|
return kUpb_JsonDecodeResult_Error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int upb_JsonDecodeDetectingNonconformance(const char* buf, size_t size,
|
|
|
|
upb_Message* msg,
|
|
|
|
const upb_MessageDef* m,
|
|
|
|
const upb_DefPool* symtab,
|
|
|
|
int options, upb_Arena* arena,
|
|
|
|
upb_Status* status) {
|
|
|
|
UPB_ASSERT(!upb_Message_IsFrozen(msg));
|
|
|
|
jsondec d;
|
|
|
|
|
|
|
|
if (size == 0) return true;
|
|
|
|
|
|
|
|
d.ptr = buf;
|
|
|
|
d.end = buf + size;
|
|
|
|
d.arena = arena;
|
|
|
|
d.symtab = symtab;
|
|
|
|
d.status = status;
|
|
|
|
d.options = options;
|
|
|
|
d.depth = 64;
|
|
|
|
d.result = kUpb_JsonDecodeResult_Ok;
|
|
|
|
d.line = 1;
|
|
|
|
d.line_begin = d.ptr;
|
|
|
|
d.debug_field = NULL;
|
|
|
|
d.is_first = false;
|
|
|
|
|
|
|
|
return upb_JsonDecoder_Decode(&d, msg, m);
|
|
|
|
}
|