summaryrefslogtreecommitdiff
path: root/upb/json/parser.c
diff options
context:
space:
mode:
Diffstat (limited to 'upb/json/parser.c')
-rw-r--r--upb/json/parser.c987
1 files changed, 513 insertions, 474 deletions
diff --git a/upb/json/parser.c b/upb/json/parser.c
index 42539ee..db7f14f 100644
--- a/upb/json/parser.c
+++ b/upb/json/parser.c
@@ -21,6 +21,7 @@
** - handling of keys/escape-sequences/etc that span input buffers.
*/
+#include <ctype.h>
#include <errno.h>
#include <float.h>
#include <math.h>
@@ -29,10 +30,6 @@
#include <stdlib.h>
#include <string.h>
-/* Need to define __USE_XOPEN before including time.h to make strptime work. */
-#ifndef __USE_XOPEN
-#define __USE_XOPEN
-#endif
#include <time.h>
#include "upb/json/parser.h"
@@ -63,7 +60,6 @@ static bool is_string_wrapper_object(upb_json_parser *p);
static bool does_string_wrapper_start(upb_json_parser *p);
static bool does_string_wrapper_end(upb_json_parser *p);
-static bool is_fieldmask_object(upb_json_parser *p);
static bool does_fieldmask_start(upb_json_parser *p);
static bool does_fieldmask_end(upb_json_parser *p);
static void start_fieldmask_object(upb_json_parser *p);
@@ -160,14 +156,13 @@ void upb_stringsink_uninit(upb_stringsink *sink) { free(sink->ptr); }
typedef struct {
/* For encoding Any value field in binary format. */
- const upb_handlers *encoder_handlers;
- upb_pb_encoder *encoder;
+ upb_handlercache *encoder_handlercache;
upb_stringsink stringsink;
/* For decoding Any value field in json format. */
- upb_json_parsermethod *parser_method;
- upb_json_parser* parser;
+ upb_json_codecache *parser_codecache;
upb_sink sink;
+ upb_json_parser *parser;
/* Mark the range of uninterpreted values in json input before type url. */
const char *before_type_url_start;
@@ -186,7 +181,12 @@ typedef struct {
const upb_fielddef *f;
/* The table mapping json name to fielddef for this message. */
- upb_strtable *name_table;
+ const upb_strtable *name_table;
+
+ /* We are in a repeated-field context. We need this flag to decide whether to
+ * handle the array as a normal repeated field or a
+ * google.protobuf.ListValue/google.protobuf.Value. */
+ bool is_repeated;
/* We are in a repeated-field context, ready to emit mapentries as
* submessages. This flag alters the start-of-object (open-brace) behavior to
@@ -218,8 +218,21 @@ typedef struct {
bool is_unknown_field;
} upb_jsonparser_frame;
+static void init_frame(upb_jsonparser_frame* frame) {
+ frame->m = NULL;
+ frame->f = NULL;
+ frame->name_table = NULL;
+ frame->is_repeated = false;
+ frame->is_map = false;
+ frame->is_mapentry = false;
+ frame->mapfield = NULL;
+ frame->is_any = false;
+ frame->any_frame = NULL;
+ frame->is_unknown_field = false;
+}
+
struct upb_json_parser {
- upb_env *env;
+ upb_arena *arena;
const upb_json_parsermethod *method;
upb_bytessink input_;
@@ -228,7 +241,7 @@ struct upb_json_parser {
upb_jsonparser_frame *top;
upb_jsonparser_frame *limit;
- upb_status status;
+ upb_status *status;
/* Ragel's internal parsing stack for the parsing state machine. */
int current_state;
@@ -265,64 +278,75 @@ struct upb_json_parser {
struct tm tm;
};
-struct upb_json_parsermethod {
- upb_refcounted base;
+static upb_jsonparser_frame* start_jsonparser_frame(upb_json_parser *p) {
+ upb_jsonparser_frame *inner;
+ inner = p->top + 1;
+ init_frame(inner);
+ return inner;
+}
- upb_byteshandler input_handler_;
+struct upb_json_codecache {
+ upb_arena *arena;
+ upb_inttable methods; /* upb_msgdef* -> upb_json_parsermethod* */
+};
- /* Mainly for the purposes of refcounting, so all the fielddefs we point
- * to stay alive. */
- const upb_msgdef *msg;
+struct upb_json_parsermethod {
+ const upb_json_codecache *cache;
+ upb_byteshandler input_handler_;
- /* Keys are upb_msgdef*, values are upb_strtable (json_name -> fielddef) */
- upb_inttable name_tables;
+ /* Maps json_name -> fielddef */
+ upb_strtable name_table;
};
#define PARSER_CHECK_RETURN(x) if (!(x)) return false
-static void json_parser_any_frame_reset(upb_jsonparser_any_frame *frame) {
- frame->encoder_handlers = NULL;
- frame->encoder = NULL;
- frame->parser_method = NULL;
+static upb_jsonparser_any_frame *json_parser_any_frame_new(
+ upb_json_parser *p) {
+ upb_jsonparser_any_frame *frame;
+
+ frame = upb_arena_malloc(p->arena, sizeof(upb_jsonparser_any_frame));
+
+ frame->encoder_handlercache = upb_pb_encoder_newcache();
+ frame->parser_codecache = upb_json_codecache_new();
frame->parser = NULL;
frame->before_type_url_start = NULL;
frame->before_type_url_end = NULL;
frame->after_type_url_start = NULL;
+
+ upb_stringsink_init(&frame->stringsink);
+
+ return frame;
}
static void json_parser_any_frame_set_payload_type(
upb_json_parser *p,
upb_jsonparser_any_frame *frame,
const upb_msgdef *payload_type) {
+ const upb_handlers *h;
+ const upb_json_parsermethod *parser_method;
+ upb_pb_encoder *encoder;
+
/* Initialize encoder. */
- frame->encoder_handlers =
- upb_pb_encoder_newhandlers(payload_type, &frame->encoder_handlers);
- upb_stringsink_init(&frame->stringsink);
- frame->encoder =
- upb_pb_encoder_create(
- p->env, frame->encoder_handlers,
- &frame->stringsink.sink);
+ h = upb_handlercache_get(frame->encoder_handlercache, payload_type);
+ encoder = upb_pb_encoder_create(p->arena, h, frame->stringsink.sink);
/* Initialize parser. */
- frame->parser_method =
- upb_json_parsermethod_new(payload_type, &frame->parser_method);
- upb_sink_reset(&frame->sink, frame->encoder_handlers, frame->encoder);
+ parser_method = upb_json_codecache_get(frame->parser_codecache, payload_type);
+ upb_sink_reset(&frame->sink, h, encoder);
frame->parser =
- upb_json_parser_create(p->env, frame->parser_method, p->symtab,
- &frame->sink, p->ignore_json_unknown);
+ upb_json_parser_create(p->arena, parser_method, p->symtab, frame->sink,
+ p->status, p->ignore_json_unknown);
}
static void json_parser_any_frame_free(upb_jsonparser_any_frame *frame) {
- upb_handlers_unref(frame->encoder_handlers,
- &frame->encoder_handlers);
- upb_json_parsermethod_unref(frame->parser_method,
- &frame->parser_method);
+ upb_handlercache_free(frame->encoder_handlercache);
+ upb_json_codecache_free(frame->parser_codecache);
upb_stringsink_uninit(&frame->stringsink);
}
static bool json_parser_any_frame_has_type_url(
upb_jsonparser_any_frame *frame) {
- return frame->encoder != NULL;
+ return frame->parser != NULL;
}
static bool json_parser_any_frame_has_value_before_type_url(
@@ -344,7 +368,7 @@ static bool json_parser_any_frame_has_value(
static void json_parser_any_frame_set_before_type_url_end(
upb_jsonparser_any_frame *frame,
const char *ptr) {
- if (frame->encoder == NULL) {
+ if (frame->parser == NULL) {
frame->before_type_url_end = ptr;
}
}
@@ -376,8 +400,7 @@ static upb_selector_t parser_getsel(upb_json_parser *p) {
static bool check_stack(upb_json_parser *p) {
if ((p->top + 1) == p->limit) {
- upb_status_seterrmsg(&p->status, "Nesting too deep");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrmsg(p->status, "Nesting too deep");
return false;
}
@@ -386,9 +409,15 @@ static bool check_stack(upb_json_parser *p) {
static void set_name_table(upb_json_parser *p, upb_jsonparser_frame *frame) {
upb_value v;
- bool ok = upb_inttable_lookupptr(&p->method->name_tables, frame->m, &v);
+ const upb_json_codecache *cache = p->method->cache;
+ bool ok;
+ const upb_json_parsermethod *method;
+
+ ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
UPB_ASSERT(ok);
- frame->name_table = upb_value_getptr(v);
+ method = upb_value_getconstptr(v);
+
+ frame->name_table = &method->name_table;
}
/* There are GCC/Clang built-ins for overflow checking which we could start
@@ -466,10 +495,9 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
char output[3];
if (limit - ptr < 4) {
- upb_status_seterrf(&p->status,
+ upb_status_seterrf(p->status,
"Base64 input for bytes field not a multiple of 4: %s",
upb_fielddef_name(p->top->f));
- upb_env_reporterror(p->env, &p->status);
return false;
}
@@ -486,17 +514,16 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
output[0] = val >> 16;
output[1] = (val >> 8) & 0xff;
output[2] = val & 0xff;
- upb_sink_putstring(&p->top->sink, sel, output, 3, NULL);
+ upb_sink_putstring(p->top->sink, sel, output, 3, NULL);
}
return true;
otherchar:
if (nonbase64(ptr[0]) || nonbase64(ptr[1]) || nonbase64(ptr[2]) ||
nonbase64(ptr[3]) ) {
- upb_status_seterrf(&p->status,
+ upb_status_seterrf(p->status,
"Non-base64 characters in bytes field: %s",
upb_fielddef_name(p->top->f));
- upb_env_reporterror(p->env, &p->status);
return false;
} if (ptr[2] == '=') {
uint32_t val;
@@ -512,7 +539,7 @@ otherchar:
UPB_ASSERT(!(val & 0x80000000));
output = val >> 16;
- upb_sink_putstring(&p->top->sink, sel, &output, 1, NULL);
+ upb_sink_putstring(p->top->sink, sel, &output, 1, NULL);
return true;
} else {
uint32_t val;
@@ -529,16 +556,15 @@ otherchar:
output[0] = val >> 16;
output[1] = (val >> 8) & 0xff;
- upb_sink_putstring(&p->top->sink, sel, output, 2, NULL);
+ upb_sink_putstring(p->top->sink, sel, output, 2, NULL);
return true;
}
badpadding:
- upb_status_seterrf(&p->status,
+ upb_status_seterrf(p->status,
"Incorrect base64 padding for field: %s (%.*s)",
upb_fielddef_name(p->top->f),
4, ptr);
- upb_env_reporterror(p->env, &p->status);
return false;
}
@@ -582,10 +608,9 @@ static bool accumulate_realloc(upb_json_parser *p, size_t need) {
new_size = saturating_multiply(new_size, 2);
}
- mem = upb_env_realloc(p->env, p->accumulate_buf, old_size, new_size);
+ mem = upb_arena_realloc(p->arena, p->accumulate_buf, old_size, new_size);
if (!mem) {
- upb_status_seterrmsg(&p->status, "Out of memory allocating buffer.");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrmsg(p->status, "Out of memory allocating buffer.");
return false;
}
@@ -608,8 +633,7 @@ static bool accumulate_append(upb_json_parser *p, const char *buf, size_t len,
}
if (!checked_add(p->accumulated_len, len, &need)) {
- upb_status_seterrmsg(&p->status, "Integer overflow.");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrmsg(p->status, "Integer overflow.");
return false;
}
@@ -687,8 +711,7 @@ static bool multipart_text(upb_json_parser *p, const char *buf, size_t len,
switch (p->multipart_state) {
case MULTIPART_INACTIVE:
upb_status_seterrmsg(
- &p->status, "Internal error: unexpected state MULTIPART_INACTIVE");
- upb_env_reporterror(p->env, &p->status);
+ p->status, "Internal error: unexpected state MULTIPART_INACTIVE");
return false;
case MULTIPART_ACCUMULATE:
@@ -699,7 +722,7 @@ static bool multipart_text(upb_json_parser *p, const char *buf, size_t len,
case MULTIPART_PUSHEAGERLY: {
const upb_bufhandle *handle = can_alias ? p->handle : NULL;
- upb_sink_putstring(&p->top->sink, p->string_selector, buf, len, handle);
+ upb_sink_putstring(p->top->sink, p->string_selector, buf, len, handle);
break;
}
}
@@ -945,7 +968,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
} else if (val > INT32_MAX || val < INT32_MIN) {
return false;
} else {
- upb_sink_putint32(&p->top->sink, parser_getsel(p), val);
+ upb_sink_putint32(p->top->sink, parser_getsel(p), val);
return true;
}
}
@@ -956,7 +979,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
} else if (val > UINT32_MAX || errno == ERANGE) {
return false;
} else {
- upb_sink_putuint32(&p->top->sink, parser_getsel(p), val);
+ upb_sink_putuint32(p->top->sink, parser_getsel(p), val);
return true;
}
}
@@ -967,7 +990,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
if (errno == ERANGE || end != bufend) {
break;
} else {
- upb_sink_putint64(&p->top->sink, parser_getsel(p), val);
+ upb_sink_putint64(p->top->sink, parser_getsel(p), val);
return true;
}
}
@@ -978,7 +1001,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
} else if (errno == ERANGE) {
return false;
} else {
- upb_sink_putuint64(&p->top->sink, parser_getsel(p), val);
+ upb_sink_putuint64(p->top->sink, parser_getsel(p), val);
return true;
}
}
@@ -1009,7 +1032,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
if (modf(val, &dummy) != 0 || val > max || val < min) { \
return false; \
} else { \
- upb_sink_put ## smalltype(&p->top->sink, parser_getsel(p), \
+ upb_sink_put ## smalltype(p->top->sink, parser_getsel(p), \
(ctype)val); \
return true; \
} \
@@ -1023,13 +1046,13 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
#undef CASE
case UPB_TYPE_DOUBLE:
- upb_sink_putdouble(&p->top->sink, parser_getsel(p), val);
+ upb_sink_putdouble(p->top->sink, parser_getsel(p), val);
return true;
case UPB_TYPE_FLOAT:
if ((val > FLT_MAX || val < -FLT_MAX) && val != inf && val != -inf) {
return false;
} else {
- upb_sink_putfloat(&p->top->sink, parser_getsel(p), val);
+ upb_sink_putfloat(p->top->sink, parser_getsel(p), val);
return true;
}
default:
@@ -1053,8 +1076,7 @@ static bool parse_number(upb_json_parser *p, bool is_quoted) {
multipart_end(p);
return true;
} else {
- upb_status_seterrf(&p->status, "error parsing number: %s", buf);
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrf(p->status, "error parsing number: %s", buf);
multipart_end(p);
return false;
}
@@ -1068,14 +1090,13 @@ static bool parser_putbool(upb_json_parser *p, bool val) {
}
if (upb_fielddef_type(p->top->f) != UPB_TYPE_BOOL) {
- upb_status_seterrf(&p->status,
+ upb_status_seterrf(p->status,
"Boolean value specified for non-bool field: %s",
upb_fielddef_name(p->top->f));
- upb_env_reporterror(p->env, &p->status);
return false;
}
- ok = upb_sink_putbool(&p->top->sink, parser_getsel(p), val);
+ ok = upb_sink_putbool(p->top->sink, parser_getsel(p), val);
UPB_ASSERT(ok);
return true;
@@ -1222,17 +1243,11 @@ static bool start_stringval(upb_json_parser *p) {
/* Start a new parser frame: parser frames correspond one-to-one with
* handler frames, and string events occur in a sub-frame. */
- inner = p->top + 1;
+ inner = start_jsonparser_frame(p);
sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
- upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+ upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
inner->m = p->top->m;
inner->f = p->top->f;
- inner->name_table = NULL;
- inner->is_map = false;
- inner->is_mapentry = false;
- inner->is_any = false;
- inner->any_frame = NULL;
- inner->is_unknown_field = false;
p->top = inner;
if (upb_fielddef_type(p->top->f) == UPB_TYPE_STRING) {
@@ -1255,10 +1270,9 @@ static bool start_stringval(upb_json_parser *p) {
multipart_startaccum(p);
return true;
} else {
- upb_status_seterrf(&p->status,
+ upb_status_seterrf(p->status,
"String specified for bool or submessage field: %s",
upb_fielddef_name(p->top->f));
- upb_env_reporterror(p->env, &p->status);
return false;
}
}
@@ -1274,11 +1288,11 @@ static bool end_any_stringval(upb_json_parser *p) {
inner = p->top + 1;
sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
- upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+ upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
- upb_sink_putstring(&inner->sink, sel, buf, len, NULL);
+ upb_sink_putstring(inner->sink, sel, buf, len, NULL);
sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
- upb_sink_endstr(&inner->sink, sel);
+ upb_sink_endstr(inner->sink, sel);
multipart_end(p);
@@ -1291,18 +1305,16 @@ static bool end_any_stringval(upb_json_parser *p) {
payload_type = upb_symtab_lookupmsg2(p->symtab, buf, len);
if (payload_type == NULL) {
upb_status_seterrf(
- &p->status, "Cannot find packed type: %.*s\n", (int)len, buf);
- upb_env_reporterror(p->env, &p->status);
+ p->status, "Cannot find packed type: %.*s\n", (int)len, buf);
return false;
}
json_parser_any_frame_set_payload_type(p, p->top->any_frame, payload_type);
-
+
return true;
} else {
upb_status_seterrf(
- &p->status, "Invalid type url: %.*s\n", (int)len, buf);
- upb_env_reporterror(p->env, &p->status);
+ p->status, "Invalid type url: %.*s\n", (int)len, buf);
return false;
}
}
@@ -1335,15 +1347,14 @@ static bool end_stringval_nontop(upb_json_parser *p) {
case UPB_TYPE_STRING: {
upb_selector_t sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
- upb_sink_endstr(&p->top->sink, sel);
+ upb_sink_endstr(p->top->sink, sel);
p->top--;
break;
}
case UPB_TYPE_ENUM: {
/* Resolve enum symbolic name to integer value. */
- const upb_enumdef *enumdef =
- (const upb_enumdef*)upb_fielddef_subdef(p->top->f);
+ const upb_enumdef *enumdef = upb_fielddef_enumsubdef(p->top->f);
size_t len;
const char *buf = accumulate_getptr(p, &len);
@@ -1353,10 +1364,9 @@ static bool end_stringval_nontop(upb_json_parser *p) {
if (ok) {
upb_selector_t sel = parser_getsel(p);
- upb_sink_putint32(&p->top->sink, sel, int_val);
+ upb_sink_putint32(p->top->sink, sel, int_val);
} else {
- upb_status_seterrf(&p->status, "Enum value unknown: '%.*s'", len, buf);
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrf(p->status, "Enum value unknown: '%.*s'", len, buf);
}
break;
@@ -1373,8 +1383,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
default:
UPB_ASSERT(false);
- upb_status_seterrmsg(&p->status, "Internal error in JSON decoder");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrmsg(p->status, "Internal error in JSON decoder");
ok = false;
break;
}
@@ -1464,25 +1473,22 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
memcpy(seconds_buf, buf, fraction_start);
seconds = strtol(seconds_buf, &end, 10);
if (errno == ERANGE || end != seconds_buf + fraction_start) {
- upb_status_seterrf(&p->status, "error parsing duration: %s",
+ upb_status_seterrf(p->status, "error parsing duration: %s",
seconds_buf);
- upb_env_reporterror(p->env, &p->status);
return false;
}
if (seconds > 315576000000) {
- upb_status_seterrf(&p->status, "error parsing duration: "
+ upb_status_seterrf(p->status, "error parsing duration: "
"maximum acceptable value is "
"315576000000");
- upb_env_reporterror(p->env, &p->status);
return false;
}
if (seconds < -315576000000) {
- upb_status_seterrf(&p->status, "error parsing duration: "
+ upb_status_seterrf(p->status, "error parsing duration: "
"minimum acceptable value is "
"-315576000000");
- upb_env_reporterror(p->env, &p->status);
return false;
}
@@ -1491,9 +1497,8 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
memcpy(nanos_buf + 1, buf + fraction_start, len - fraction_start);
val = strtod(nanos_buf, &end);
if (errno == ERANGE || end != nanos_buf + len - fraction_start + 1) {
- upb_status_seterrf(&p->status, "error parsing duration: %s",
+ upb_status_seterrf(p->status, "error parsing duration: %s",
nanos_buf);
- upb_env_reporterror(p->env, &p->status);
return false;
}
@@ -1508,7 +1513,7 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
capture_begin(p, seconds_membername);
capture_end(p, seconds_membername + 7);
end_membername(p);
- upb_sink_putint64(&p->top->sink, parser_getsel(p), seconds);
+ upb_sink_putint64(p->top->sink, parser_getsel(p), seconds);
end_member(p);
/* Set nanos */
@@ -1516,51 +1521,109 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
capture_begin(p, nanos_membername);
capture_end(p, nanos_membername + 5);
end_membername(p);
- upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
+ upb_sink_putint32(p->top->sink, parser_getsel(p), nanos);
end_member(p);
- /* Continue previous environment */
+ /* Continue previous arena */
multipart_startaccum(p);
return true;
}
-static void start_timestamp_base(upb_json_parser *p, const char *ptr) {
+static int parse_timestamp_number(upb_json_parser *p) {
+ size_t len;
+ const char *buf;
+ char *end;
+ int val;
+
+ /* atoi() and friends unfortunately do not support specifying the length of
+ * the input string, so we need to force a copy into a NULL-terminated buffer. */
+ multipart_text(p, "\0", 1, false);
+
+ buf = accumulate_getptr(p, &len);
+ val = atoi(buf);
+ multipart_end(p);
+ multipart_startaccum(p);
+
+ return val;
+}
+
+static void start_year(upb_json_parser *p, const char *ptr) {
capture_begin(p, ptr);
}
-#define UPB_TIMESTAMP_BASE_SIZE 19
+static bool end_year(upb_json_parser *p, const char *ptr) {
+ if (!capture_end(p, ptr)) {
+ return false;
+ }
+ p->tm.tm_year = parse_timestamp_number(p) - 1900;
+ return true;
+}
-static bool end_timestamp_base(upb_json_parser *p, const char *ptr) {
- size_t len;
- const char *buf;
- /* 3 for GMT and 1 for ending 0 */
- char timestamp_buf[UPB_TIMESTAMP_BASE_SIZE + 4];
+static void start_month(upb_json_parser *p, const char *ptr) {
+ capture_begin(p, ptr);
+}
+static bool end_month(upb_json_parser *p, const char *ptr) {
if (!capture_end(p, ptr)) {
return false;
}
+ p->tm.tm_mon = parse_timestamp_number(p) - 1;
+ return true;
+}
- buf = accumulate_getptr(p, &len);
- UPB_ASSERT(len == UPB_TIMESTAMP_BASE_SIZE);
- memcpy(timestamp_buf, buf, UPB_TIMESTAMP_BASE_SIZE);
- memcpy(timestamp_buf + UPB_TIMESTAMP_BASE_SIZE, "GMT", 3);
- timestamp_buf[UPB_TIMESTAMP_BASE_SIZE + 3] = 0;
-
- /* Parse seconds */
- if (strptime(timestamp_buf, "%FT%H:%M:%S%Z", &p->tm) == NULL) {
- upb_status_seterrf(&p->status, "error parsing timestamp: %s", buf);
- upb_env_reporterror(p->env, &p->status);
+static void start_day(upb_json_parser *p, const char *ptr) {
+ capture_begin(p, ptr);
+}
+
+static bool end_day(upb_json_parser *p, const char *ptr) {
+ if (!capture_end(p, ptr)) {
return false;
}
+ p->tm.tm_mday = parse_timestamp_number(p);
+ return true;
+}
- /* Clean up buffer */
- multipart_end(p);
- multipart_startaccum(p);
+static void start_hour(upb_json_parser *p, const char *ptr) {
+ capture_begin(p, ptr);
+}
+
+static bool end_hour(upb_json_parser *p, const char *ptr) {
+ if (!capture_end(p, ptr)) {
+ return false;
+ }
+ p->tm.tm_hour = parse_timestamp_number(p);
+ return true;
+}
+
+static void start_minute(upb_json_parser *p, const char *ptr) {
+ capture_begin(p, ptr);
+}
+
+static bool end_minute(upb_json_parser *p, const char *ptr) {
+ if (!capture_end(p, ptr)) {
+ return false;
+ }
+ p->tm.tm_min = parse_timestamp_number(p);
+ return true;
+}
+
+static void start_second(upb_json_parser *p, const char *ptr) {
+ capture_begin(p, ptr);
+}
+static bool end_second(upb_json_parser *p, const char *ptr) {
+ if (!capture_end(p, ptr)) {
+ return false;
+ }
+ p->tm.tm_sec = parse_timestamp_number(p);
return true;
}
+static void start_timestamp_base(upb_json_parser *p) {
+ memset(&p->tm, 0, sizeof(struct tm));
+}
+
static void start_timestamp_fraction(upb_json_parser *p, const char *ptr) {
capture_begin(p, ptr);
}
@@ -1583,9 +1646,8 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
buf = accumulate_getptr(p, &len);
if (len > 10) {
- upb_status_seterrf(&p->status,
+ upb_status_seterrf(p->status,
"error parsing timestamp: at most 9-digit fraction.");
- upb_env_reporterror(p->env, &p->status);
return false;
}
@@ -1595,9 +1657,8 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
val = strtod(nanos_buf, &end);
if (errno == ERANGE || end != nanos_buf + len + 1) {
- upb_status_seterrf(&p->status, "error parsing timestamp nanos: %s",
+ upb_status_seterrf(p->status, "error parsing timestamp nanos: %s",
nanos_buf);
- upb_env_reporterror(p->env, &p->status);
return false;
}
@@ -1611,7 +1672,7 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
capture_begin(p, nanos_membername);
capture_end(p, nanos_membername + 5);
end_membername(p);
- upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
+ upb_sink_putint32(p->top->sink, parser_getsel(p), nanos);
end_member(p);
/* Continue previous environment */
@@ -1639,8 +1700,7 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
if (buf[0] != 'Z') {
if (sscanf(buf + 1, "%2d:00", &hours) != 1) {
- upb_status_seterrf(&p->status, "error parsing timestamp offset");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrf(p->status, "error parsing timestamp offset");
return false;
}
@@ -1656,10 +1716,9 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
/* Check timestamp boundary */
if (seconds < -62135596800) {
- upb_status_seterrf(&p->status, "error parsing timestamp: "
+ upb_status_seterrf(p->status, "error parsing timestamp: "
"minimum acceptable value is "
"0001-01-01T00:00:00Z");
- upb_env_reporterror(p->env, &p->status);
return false;
}
@@ -1671,7 +1730,7 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
capture_begin(p, seconds_membername);
capture_end(p, seconds_membername + 7);
end_membername(p);
- upb_sink_putint64(&p->top->sink, parser_getsel(p), seconds);
+ upb_sink_putint64(p->top->sink, parser_getsel(p), seconds);
end_member(p);
/* Continue previous environment */
@@ -1685,9 +1744,7 @@ static void start_fieldmask_path_text(upb_json_parser *p, const char *ptr) {
}
static bool end_fieldmask_path_text(upb_json_parser *p, const char *ptr) {
- if (!capture_end(p, ptr)) {
- return false;
- }
+ return capture_end(p, ptr);
}
static bool start_fieldmask_path(upb_json_parser *p) {
@@ -1698,17 +1755,11 @@ static bool start_fieldmask_path(upb_json_parser *p) {
/* Start a new parser frame: parser frames correspond one-to-one with
* handler frames, and string events occur in a sub-frame. */
- inner = p->top + 1;
+ inner = start_jsonparser_frame(p);
sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
- upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+ upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
inner->m = p->top->m;
inner->f = p->top->f;
- inner->name_table = NULL;
- inner->is_map = false;
- inner->is_mapentry = false;
- inner->is_any = false;
- inner->any_frame = NULL;
- inner->is_unknown_field = false;
p->top = inner;
multipart_startaccum(p);
@@ -1722,10 +1773,10 @@ static bool lower_camel_push(
for (;ptr < limit; ptr++) {
if (*ptr >= 'A' && *ptr <= 'Z' && !first) {
char lower = tolower(*ptr);
- upb_sink_putstring(&p->top->sink, sel, "_", 1, NULL);
- upb_sink_putstring(&p->top->sink, sel, &lower, 1, NULL);
+ upb_sink_putstring(p->top->sink, sel, "_", 1, NULL);
+ upb_sink_putstring(p->top->sink, sel, &lower, 1, NULL);
} else {
- upb_sink_putstring(&p->top->sink, sel, ptr, 1, NULL);
+ upb_sink_putstring(p->top->sink, sel, ptr, 1, NULL);
}
first = false;
}
@@ -1742,7 +1793,7 @@ static bool end_fieldmask_path(upb_json_parser *p) {
}
sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
- upb_sink_endstr(&p->top->sink, sel);
+ upb_sink_endstr(p->top->sink, sel);
p->top--;
multipart_end(p);
@@ -1769,8 +1820,7 @@ static bool parse_mapentry_key(upb_json_parser *p) {
p->top->f = upb_msgdef_itof(p->top->m, UPB_MAPENTRY_KEY);
if (p->top->f == NULL) {
- upb_status_seterrmsg(&p->status, "mapentry message has no key");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrmsg(p->status, "mapentry message has no key");
return false;
}
switch (upb_fielddef_type(p->top->f)) {
@@ -1793,9 +1843,8 @@ static bool parse_mapentry_key(upb_json_parser *p) {
return false;
}
} else {
- upb_status_seterrmsg(&p->status,
+ upb_status_seterrmsg(p->status,
"Map bool key not 'true' or 'false'");
- upb_env_reporterror(p->env, &p->status);
return false;
}
multipart_end(p);
@@ -1804,17 +1853,16 @@ static bool parse_mapentry_key(upb_json_parser *p) {
case UPB_TYPE_BYTES: {
upb_sink subsink;
upb_selector_t sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
- upb_sink_startstr(&p->top->sink, sel, len, &subsink);
+ upb_sink_startstr(p->top->sink, sel, len, &subsink);
sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
- upb_sink_putstring(&subsink, sel, buf, len, NULL);
+ upb_sink_putstring(subsink, sel, buf, len, NULL);
sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
- upb_sink_endstr(&subsink, sel);
+ upb_sink_endstr(subsink, sel);
multipart_end(p);
break;
}
default:
- upb_status_seterrmsg(&p->status, "Invalid field type for map key");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrmsg(p->status, "Invalid field type for map key");
return false;
}
@@ -1844,17 +1892,12 @@ static bool handle_mapentry(upb_json_parser *p) {
mapfield = p->top->mapfield;
mapentrymsg = upb_fielddef_msgsubdef(mapfield);
- inner = p->top + 1;
+ inner = start_jsonparser_frame(p);
p->top->f = mapfield;
sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSUBMSG);
- upb_sink_startsubmsg(&p->top->sink, sel, &inner->sink);
+ upb_sink_startsubmsg(p->top->sink, sel, &inner->sink);
inner->m = mapentrymsg;
- inner->name_table = NULL;
inner->mapfield = mapfield;
- inner->is_map = false;
- inner->is_any = false;
- inner->any_frame = NULL;
- inner->is_unknown_field = false;
/* Don't set this to true *yet* -- we reuse parsing handlers below to push
* the key field value to the sink, and these handlers will pop the frame
@@ -1864,7 +1907,7 @@ static bool handle_mapentry(upb_json_parser *p) {
p->top = inner;
/* send STARTMSG in submsg frame. */
- upb_sink_startmsg(&p->top->sink);
+ upb_sink_startmsg(p->top->sink);
parse_mapentry_key(p);
@@ -1873,8 +1916,7 @@ static bool handle_mapentry(upb_json_parser *p) {
p->top->is_mapentry = true; /* set up to pop frame after value is parsed. */
p->top->mapfield = mapfield;
if (p->top->f == NULL) {
- upb_status_seterrmsg(&p->status, "mapentry message has no value");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrmsg(p->status, "mapentry message has no value");
return false;
}
@@ -1909,8 +1951,7 @@ static bool end_membername(upb_json_parser *p) {
multipart_end(p);
return true;
} else {
- upb_status_seterrf(&p->status, "No such field: %.*s\n", (int)len, buf);
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrf(p->status, "No such field: %.*s\n", (int)len, buf);
return false;
}
}
@@ -1936,21 +1977,20 @@ static bool end_any_membername(upb_json_parser *p) {
static void end_member(upb_json_parser *p) {
/* If we just parsed a map-entry value, end that frame too. */
if (p->top->is_mapentry) {
- upb_status s = UPB_STATUS_INIT;
upb_selector_t sel;
bool ok;
const upb_fielddef *mapfield;
UPB_ASSERT(p->top > p->stack);
/* send ENDMSG on submsg. */
- upb_sink_endmsg(&p->top->sink, &s);
+ upb_sink_endmsg(p->top->sink, p->status);
mapfield = p->top->mapfield;
/* send ENDSUBMSG in repeated-field-of-mapentries frame. */
p->top--;
ok = upb_handlers_getselector(mapfield, UPB_HANDLER_ENDSUBMSG, &sel);
UPB_ASSERT(ok);
- upb_sink_endsubmsg(&p->top->sink, sel);
+ upb_sink_endsubmsg(p->top->sink, sel);
}
p->top->f = NULL;
@@ -1972,15 +2012,7 @@ static bool start_subobject(upb_json_parser *p) {
upb_jsonparser_frame *inner;
if (!check_stack(p)) return false;
- inner = p->top + 1;
- inner->m = NULL;
- inner->f = NULL;
- inner->is_map = false;
- inner->is_mapentry = false;
- inner->is_any = false;
- inner->any_frame = NULL;
- inner->is_unknown_field = false;
- p->top = inner;
+ p->top = start_jsonparser_frame(p);
return true;
}
@@ -1992,18 +2024,12 @@ static bool start_subobject(upb_json_parser *p) {
* context. */
if (!check_stack(p)) return false;
- inner = p->top + 1;
+ inner = start_jsonparser_frame(p);
sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSEQ);
- upb_sink_startseq(&p->top->sink, sel, &inner->sink);
+ upb_sink_startseq(p->top->sink, sel, &inner->sink);
inner->m = upb_fielddef_msgsubdef(p->top->f);
- inner->name_table = NULL;
inner->mapfield = p->top->f;
- inner->f = NULL;
inner->is_map = true;
- inner->is_mapentry = false;
- inner->is_any = false;
- inner->any_frame = NULL;
- inner->is_unknown_field = false;
p->top = inner;
return true;
@@ -2015,23 +2041,16 @@ static bool start_subobject(upb_json_parser *p) {
* context. */
if (!check_stack(p)) return false;
- inner = p->top + 1;
-
+ inner = start_jsonparser_frame(p);
sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSUBMSG);
- upb_sink_startsubmsg(&p->top->sink, sel, &inner->sink);
+ upb_sink_startsubmsg(p->top->sink, sel, &inner->sink);
inner->m = upb_fielddef_msgsubdef(p->top->f);
set_name_table(p, inner);
- inner->f = NULL;
- inner->is_map = false;
- inner->is_mapentry = false;
- inner->is_unknown_field = false;
p->top = inner;
if (is_wellknown_msg(p, UPB_WELLKNOWN_ANY)) {
p->top->is_any = true;
- p->top->any_frame =
- upb_env_malloc(p->env, sizeof(upb_jsonparser_any_frame));
- json_parser_any_frame_reset(p->top->any_frame);
+ p->top->any_frame = json_parser_any_frame_new(p);
} else {
p->top->is_any = false;
p->top->any_frame = NULL;
@@ -2039,10 +2058,9 @@ static bool start_subobject(upb_json_parser *p) {
return true;
} else {
- upb_status_seterrf(&p->status,
+ upb_status_seterrf(p->status,
"Object specified for non-message/group field: %s",
upb_fielddef_name(p->top->f));
- upb_env_reporterror(p->env, &p->status);
return false;
}
}
@@ -2080,14 +2098,14 @@ static void end_subobject(upb_json_parser *p) {
upb_selector_t sel;
p->top--;
sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSEQ);
- upb_sink_endseq(&p->top->sink, sel);
+ upb_sink_endseq(p->top->sink, sel);
} else {
upb_selector_t sel;
bool is_unknown = p->top->m == NULL;
p->top--;
if (!is_unknown) {
sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSUBMSG);
- upb_sink_endsubmsg(&p->top->sink, sel);
+ upb_sink_endsubmsg(p->top->sink, sel);
}
}
}
@@ -2124,10 +2142,14 @@ static bool start_array(upb_json_parser *p) {
} else {
return false;
}
- } else if (is_wellknown_field(p, UPB_WELLKNOWN_LISTVALUE)) {
+ } else if (is_wellknown_field(p, UPB_WELLKNOWN_LISTVALUE) &&
+ (!upb_fielddef_isseq(p->top->f) ||
+ p->top->is_repeated)) {
if (!start_subobject(p)) return false;
start_listvalue_object(p);
- } else if (is_wellknown_field(p, UPB_WELLKNOWN_VALUE)) {
+ } else if (is_wellknown_field(p, UPB_WELLKNOWN_VALUE) &&
+ (!upb_fielddef_isseq(p->top->f) ||
+ p->top->is_repeated)) {
if (!start_subobject(p)) return false;
start_value_object(p, VALUE_LISTVALUE);
if (!start_subobject(p)) return false;
@@ -2135,14 +2157,7 @@ static bool start_array(upb_json_parser *p) {
}
if (p->top->is_unknown_field) {
- inner = p->top + 1;
- inner->m = NULL;
- inner->name_table = NULL;
- inner->f = NULL;
- inner->is_map = false;
- inner->is_mapentry = false;
- inner->is_any = false;
- inner->any_frame = NULL;
+ inner = start_jsonparser_frame(p);
inner->is_unknown_field = true;
p->top = inner;
@@ -2150,26 +2165,20 @@ static bool start_array(upb_json_parser *p) {
}
if (!upb_fielddef_isseq(p->top->f)) {
- upb_status_seterrf(&p->status,
+ upb_status_seterrf(p->status,
"Array specified for non-repeated field: %s",
upb_fielddef_name(p->top->f));
- upb_env_reporterror(p->env, &p->status);
return false;
}
if (!check_stack(p)) return false;
- inner = p->top + 1;
+ inner = start_jsonparser_frame(p);
sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSEQ);
- upb_sink_startseq(&p->top->sink, sel, &inner->sink);
+ upb_sink_startseq(p->top->sink, sel, &inner->sink);
inner->m = p->top->m;
- inner->name_table = NULL;
inner->f = p->top->f;
- inner->is_map = false;
- inner->is_mapentry = false;
- inner->is_any = false;
- inner->any_frame = NULL;
- inner->is_unknown_field = false;
+ inner->is_repeated = true;
p->top = inner;
return true;
@@ -2187,7 +2196,7 @@ static void end_array(upb_json_parser *p) {
}
sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSEQ);
- upb_sink_endseq(&p->top->sink, sel);
+ upb_sink_endseq(p->top->sink, sel);
if (is_wellknown_msg(p, UPB_WELLKNOWN_LISTVALUE)) {
end_listvalue_object(p);
@@ -2206,18 +2215,13 @@ static void end_array(upb_json_parser *p) {
static void start_object(upb_json_parser *p) {
if (!p->top->is_map && p->top->m != NULL) {
- upb_sink_startmsg(&p->top->sink);
+ upb_sink_startmsg(p->top->sink);
}
}
static void end_object(upb_json_parser *p) {
if (!p->top->is_map && p->top->m != NULL) {
- upb_status status;
- upb_status_clear(&status);
- upb_sink_endmsg(&p->top->sink, &status);
- if (!upb_ok(&status)) {
- upb_env_reporterror(p->env, &status);
- }
+ upb_sink_endmsg(p->top->sink, p->status);
}
}
@@ -2236,8 +2240,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
if (json_parser_any_frame_has_value(p->top->any_frame) &&
!json_parser_any_frame_has_type_url(p->top->any_frame)) {
- upb_status_seterrmsg(&p->status, "No valid type url");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrmsg(p->status, "No valid type url");
return false;
}
@@ -2252,8 +2255,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
p->top->any_frame->before_type_url_end -
p->top->any_frame->before_type_url_start);
if (p->top->any_frame->before_type_url_start == NULL) {
- upb_status_seterrmsg(&p->status, "invalid data for well known type.");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrmsg(p->status, "invalid data for well known type.");
return false;
}
p->top->any_frame->before_type_url_start++;
@@ -2265,8 +2267,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
(ptr + 1) -
p->top->any_frame->after_type_url_start);
if (p->top->any_frame->after_type_url_start == NULL) {
- upb_status_seterrmsg(&p->status, "Invalid data for well known type.");
- upb_env_reporterror(p->env, &p->status);
+ upb_status_seterrmsg(p->status, "Invalid data for well known type.");
return false;
}
p->top->any_frame->after_type_url_start++;
@@ -2326,12 +2327,12 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
inner = p->top + 1;
sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
- upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+ upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
- upb_sink_putstring(&inner->sink, sel, p->top->any_frame->stringsink.ptr,
+ upb_sink_putstring(inner->sink, sel, p->top->any_frame->stringsink.ptr,
p->top->any_frame->stringsink.len, NULL);
sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
- upb_sink_endstr(&inner->sink, sel);
+ upb_sink_endstr(inner->sink, sel);
end_member(p);
@@ -2339,7 +2340,6 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
/* Deallocate any parse frame. */
json_parser_any_frame_free(p->top->any_frame);
- upb_env_free(p->env, p->top->any_frame);
return true;
}
@@ -2523,10 +2523,6 @@ static bool does_fieldmask_end(upb_json_parser *p) {
return p->top->m != NULL && is_fieldmask(p->top->m);
}
-static bool is_fieldmask_object(upb_json_parser *p) {
- return p->top->m != NULL && is_fieldmask(p->top->m);
-}
-
#define CHECK_RETURN_TOP(x) if (!(x)) goto error
@@ -2548,27 +2544,30 @@ static bool is_fieldmask_object(upb_json_parser *p) {
* final state once, when the closing '"' is seen. */
-#line 2730 "upb/json/parser.rl"
+#line 2749 "upb/json/parser.rl"
-#line 2556 "upb/json/parser.c"
+#line 2552 "upb/json/parser.c"
static const char _json_actions[] = {
0, 1, 0, 1, 1, 1, 3, 1,
4, 1, 6, 1, 7, 1, 8, 1,
- 9, 1, 10, 1, 11, 1, 12, 1,
- 13, 1, 24, 1, 26, 1, 28, 1,
- 29, 1, 31, 1, 32, 1, 33, 1,
- 35, 1, 37, 1, 38, 1, 39, 1,
- 40, 1, 42, 1, 43, 2, 4, 9,
- 2, 5, 6, 2, 7, 3, 2, 7,
- 9, 2, 14, 15, 2, 16, 17, 2,
- 18, 19, 2, 21, 23, 2, 22, 20,
- 2, 27, 25, 2, 29, 31, 2, 34,
- 2, 2, 35, 43, 2, 36, 25, 2,
- 38, 43, 2, 39, 43, 2, 40, 43,
- 2, 41, 30, 2, 42, 43, 3, 21,
- 23, 24, 4, 14, 15, 16, 17
+ 9, 1, 11, 1, 12, 1, 13, 1,
+ 14, 1, 15, 1, 16, 1, 17, 1,
+ 18, 1, 19, 1, 20, 1, 22, 1,
+ 23, 1, 24, 1, 35, 1, 37, 1,
+ 39, 1, 40, 1, 42, 1, 43, 1,
+ 44, 1, 46, 1, 48, 1, 49, 1,
+ 50, 1, 51, 1, 53, 1, 54, 2,
+ 4, 9, 2, 5, 6, 2, 7, 3,
+ 2, 7, 9, 2, 21, 26, 2, 25,
+ 10, 2, 27, 28, 2, 29, 30, 2,
+ 32, 34, 2, 33, 31, 2, 38, 36,
+ 2, 40, 42, 2, 45, 2, 2, 46,
+ 54, 2, 47, 36, 2, 49, 54, 2,
+ 50, 54, 2, 51, 54, 2, 52, 41,
+ 2, 53, 54, 3, 32, 34, 35, 4,
+ 21, 26, 27, 28
};
static const short _json_key_offsets[] = {
@@ -2752,30 +2751,30 @@ static const char _json_trans_targs[] = {
106
};
-static const char _json_trans_actions[] = {
- 0, 0, 92, 86, 35, 0, 0, 0,
- 104, 41, 27, 0, 37, 0, 0, 0,
+static const unsigned char _json_trans_actions[] = {
+ 0, 0, 113, 107, 53, 0, 0, 0,
+ 125, 59, 45, 0, 55, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 80, 33, 29, 0, 0, 27,
- 31, 31, 83, 0, 0, 0, 0, 0,
+ 0, 0, 101, 51, 47, 0, 0, 45,
+ 49, 49, 104, 0, 0, 0, 0, 0,
3, 0, 0, 0, 0, 0, 5, 15,
- 0, 0, 53, 7, 13, 0, 56, 9,
- 9, 9, 59, 62, 11, 17, 17, 17,
- 0, 0, 0, 19, 0, 21, 23, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 114, 65, 114, 0, 0, 0, 0,
- 0, 71, 0, 68, 68, 77, 25, 0,
- 110, 74, 92, 86, 35, 0, 0, 0,
- 104, 41, 51, 89, 27, 0, 37, 0,
- 0, 0, 0, 0, 0, 98, 0, 0,
- 0, 101, 0, 0, 0, 95, 0, 80,
- 33, 29, 0, 0, 27, 31, 31, 83,
- 0, 0, 107, 0, 39, 45, 47, 43,
- 49
+ 0, 0, 71, 7, 13, 0, 74, 9,
+ 9, 9, 77, 80, 11, 37, 37, 37,
+ 0, 0, 0, 39, 0, 41, 86, 0,
+ 0, 0, 17, 19, 0, 21, 23, 0,
+ 25, 27, 0, 29, 31, 0, 33, 35,
+ 0, 135, 83, 135, 0, 0, 0, 0,
+ 0, 92, 0, 89, 89, 98, 43, 0,
+ 131, 95, 113, 107, 53, 0, 0, 0,
+ 125, 59, 69, 110, 45, 0, 55, 0,
+ 0, 0, 0, 0, 0, 119, 0, 0,
+ 0, 122, 0, 0, 0, 116, 0, 101,
+ 51, 47, 0, 0, 45, 49, 49, 104,
+ 0, 0, 128, 0, 57, 63, 65, 61,
+ 67
};
-static const char _json_eof_actions[] = {
+static const unsigned char _json_eof_actions[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
@@ -2789,7 +2788,7 @@ static const char _json_eof_actions[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 39, 45, 47, 43, 49,
+ 0, 0, 0, 57, 63, 65, 61, 67,
0, 0, 0, 0, 0, 0
};
@@ -2804,7 +2803,7 @@ static const int json_en_value_machine = 78;
static const int json_en_main = 1;
-#line 2733 "upb/json/parser.rl"
+#line 2752 "upb/json/parser.rl"
size_t parse(void *closure, const void *hd, const char *buf, size_t size,
const upb_bufhandle *handle) {
@@ -2827,7 +2826,7 @@ size_t parse(void *closure, const void *hd, const char *buf, size_t size,
capture_resume(parser, buf);
-#line 2831 "upb/json/parser.c"
+#line 2830 "upb/json/parser.c"
{
int _klen;
unsigned int _trans;
@@ -2902,103 +2901,147 @@ _match:
switch ( *_acts++ )
{
case 1:
-#line 2561 "upb/json/parser.rl"
+#line 2557 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; goto _again;} }
break;
case 2:
-#line 2563 "upb/json/parser.rl"
+#line 2559 "upb/json/parser.rl"
{ p--; {stack[top++] = cs; cs = 23;goto _again;} }
break;
case 3:
-#line 2567 "upb/json/parser.rl"
+#line 2563 "upb/json/parser.rl"
{ start_text(parser, p); }
break;
case 4:
-#line 2568 "upb/json/parser.rl"
+#line 2564 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_text(parser, p)); }
break;
case 5:
-#line 2574 "upb/json/parser.rl"
+#line 2570 "upb/json/parser.rl"
{ start_hex(parser); }
break;
case 6:
-#line 2575 "upb/json/parser.rl"
+#line 2571 "upb/json/parser.rl"
{ hexdigit(parser, p); }
break;
case 7:
-#line 2576 "upb/json/parser.rl"
+#line 2572 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_hex(parser)); }
break;
case 8:
-#line 2582 "upb/json/parser.rl"
+#line 2578 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(escape(parser, p)); }
break;
case 9:
-#line 2588 "upb/json/parser.rl"
+#line 2584 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; goto _again;} }
break;
case 10:
-#line 2600 "upb/json/parser.rl"
- { start_duration_base(parser, p); }
+#line 2589 "upb/json/parser.rl"
+ { start_year(parser, p); }
break;
case 11:
-#line 2601 "upb/json/parser.rl"
- { CHECK_RETURN_TOP(end_duration_base(parser, p)); }
+#line 2590 "upb/json/parser.rl"
+ { CHECK_RETURN_TOP(end_year(parser, p)); }
break;
case 12:
-#line 2603 "upb/json/parser.rl"
- { p--; {cs = stack[--top]; goto _again;} }
+#line 2594 "upb/json/parser.rl"
+ { start_month(parser, p); }
break;
case 13:
-#line 2608 "upb/json/parser.rl"
- { start_timestamp_base(parser, p); }
+#line 2595 "upb/json/parser.rl"
+ { CHECK_RETURN_TOP(end_month(parser, p)); }
break;
case 14:
-#line 2609 "upb/json/parser.rl"
- { CHECK_RETURN_TOP(end_timestamp_base(parser, p)); }
+#line 2599 "upb/json/parser.rl"
+ { start_day(parser, p); }
break;
case 15:
-#line 2611 "upb/json/parser.rl"
- { start_timestamp_fraction(parser, p); }
+#line 2600 "upb/json/parser.rl"
+ { CHECK_RETURN_TOP(end_day(parser, p)); }
break;
case 16:
-#line 2612 "upb/json/parser.rl"
- { CHECK_RETURN_TOP(end_timestamp_fraction(parser, p)); }
+#line 2604 "upb/json/parser.rl"
+ { start_hour(parser, p); }
break;
case 17:
-#line 2614 "upb/json/parser.rl"
- { start_timestamp_zone(parser, p); }
+#line 2605 "upb/json/parser.rl"
+ { CHECK_RETURN_TOP(end_hour(parser, p)); }
break;
case 18:
-#line 2615 "upb/json/parser.rl"
- { CHECK_RETURN_TOP(end_timestamp_zone(parser, p)); }
+#line 2609 "upb/json/parser.rl"
+ { start_minute(parser, p); }
break;
case 19:
-#line 2617 "upb/json/parser.rl"
- { p--; {cs = stack[--top]; goto _again;} }
+#line 2610 "upb/json/parser.rl"
+ { CHECK_RETURN_TOP(end_minute(parser, p)); }
break;
case 20:
-#line 2622 "upb/json/parser.rl"
- { start_fieldmask_path_text(parser, p); }
+#line 2614 "upb/json/parser.rl"
+ { start_second(parser, p); }
break;
case 21:
-#line 2623 "upb/json/parser.rl"
- { end_fieldmask_path_text(parser, p); }
+#line 2615 "upb/json/parser.rl"
+ { CHECK_RETURN_TOP(end_second(parser, p)); }
break;
case 22:
-#line 2628 "upb/json/parser.rl"
- { start_fieldmask_path(parser); }
+#line 2620 "upb/json/parser.rl"
+ { start_duration_base(parser, p); }
break;
case 23:
-#line 2629 "upb/json/parser.rl"
- { end_fieldmask_path(parser); }
+#line 2621 "upb/json/parser.rl"
+ { CHECK_RETURN_TOP(end_duration_base(parser, p)); }
break;
case 24:
-#line 2635 "upb/json/parser.rl"
+#line 2623 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; goto _again;} }
break;
case 25:
-#line 2640 "upb/json/parser.rl"
+#line 2628 "upb/json/parser.rl"
+ { start_timestamp_base(parser); }
+ break;
+ case 26:
+#line 2630 "upb/json/parser.rl"
+ { start_timestamp_fraction(parser, p); }
+ break;
+ case 27:
+#line 2631 "upb/json/parser.rl"
+ { CHECK_RETURN_TOP(end_timestamp_fraction(parser, p)); }
+ break;
+ case 28:
+#line 2633 "upb/json/parser.rl"
+ { start_timestamp_zone(parser, p); }
+ break;
+ case 29:
+#line 2634 "upb/json/parser.rl"
+ { CHECK_RETURN_TOP(end_timestamp_zone(parser, p)); }
+ break;
+ case 30:
+#line 2636 "upb/json/parser.rl"
+ { p--; {cs = stack[--top]; goto _again;} }
+ break;
+ case 31:
+#line 2641 "upb/json/parser.rl"
+ { start_fieldmask_path_text(parser, p); }
+ break;
+ case 32:
+#line 2642 "upb/json/parser.rl"
+ { end_fieldmask_path_text(parser, p); }
+ break;
+ case 33:
+#line 2647 "upb/json/parser.rl"
+ { start_fieldmask_path(parser); }
+ break;
+ case 34:
+#line 2648 "upb/json/parser.rl"
+ { end_fieldmask_path(parser); }
+ break;
+ case 35:
+#line 2654 "upb/json/parser.rl"
+ { p--; {cs = stack[--top]; goto _again;} }
+ break;
+ case 36:
+#line 2659 "upb/json/parser.rl"
{
if (is_wellknown_msg(parser, UPB_WELLKNOWN_TIMESTAMP)) {
{stack[top++] = cs; cs = 47;goto _again;}
@@ -3011,12 +3054,12 @@ _match:
}
}
break;
- case 26:
-#line 2653 "upb/json/parser.rl"
+ case 37:
+#line 2672 "upb/json/parser.rl"
{ p--; {stack[top++] = cs; cs = 78;goto _again;} }
break;
- case 27:
-#line 2658 "upb/json/parser.rl"
+ case 38:
+#line 2677 "upb/json/parser.rl"
{
if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
start_any_member(parser, p);
@@ -3025,12 +3068,12 @@ _match:
}
}
break;
- case 28:
-#line 2665 "upb/json/parser.rl"
+ case 39:
+#line 2684 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_membername(parser)); }
break;
- case 29:
-#line 2668 "upb/json/parser.rl"
+ case 40:
+#line 2687 "upb/json/parser.rl"
{
if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
end_any_member(parser, p);
@@ -3039,8 +3082,8 @@ _match:
}
}
break;
- case 30:
-#line 2679 "upb/json/parser.rl"
+ case 41:
+#line 2698 "upb/json/parser.rl"
{
if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
start_any_object(parser, p);
@@ -3049,8 +3092,8 @@ _match:
}
}
break;
- case 31:
-#line 2688 "upb/json/parser.rl"
+ case 42:
+#line 2707 "upb/json/parser.rl"
{
if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
CHECK_RETURN_TOP(end_any_object(parser, p));
@@ -3059,55 +3102,55 @@ _match:
}
}
break;
- case 32:
-#line 2700 "upb/json/parser.rl"
+ case 43:
+#line 2719 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(start_array(parser)); }
break;
- case 33:
-#line 2704 "upb/json/parser.rl"
+ case 44:
+#line 2723 "upb/json/parser.rl"
{ end_array(parser); }
break;
- case 34:
-#line 2709 "upb/json/parser.rl"
+ case 45:
+#line 2728 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(start_number(parser, p)); }
break;
- case 35:
-#line 2710 "upb/json/parser.rl"
+ case 46:
+#line 2729 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_number(parser, p)); }
break;
- case 36:
-#line 2712 "upb/json/parser.rl"
+ case 47:
+#line 2731 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(start_stringval(parser)); }
break;
- case 37:
-#line 2713 "upb/json/parser.rl"
+ case 48:
+#line 2732 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_stringval(parser)); }
break;
- case 38:
-#line 2715 "upb/json/parser.rl"
+ case 49:
+#line 2734 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_bool(parser, true)); }
break;
- case 39:
-#line 2717 "upb/json/parser.rl"
+ case 50:
+#line 2736 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_bool(parser, false)); }
break;
- case 40:
-#line 2719 "upb/json/parser.rl"
+ case 51:
+#line 2738 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_null(parser)); }
break;
- case 41:
-#line 2721 "upb/json/parser.rl"
+ case 52:
+#line 2740 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(start_subobject_full(parser)); }
break;
- case 42:
-#line 2722 "upb/json/parser.rl"
+ case 53:
+#line 2741 "upb/json/parser.rl"
{ end_subobject_full(parser); }
break;
- case 43:
-#line 2727 "upb/json/parser.rl"
+ case 54:
+#line 2746 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; goto _again;} }
break;
-#line 3111 "upb/json/parser.c"
+#line 3154 "upb/json/parser.c"
}
}
@@ -3124,32 +3167,32 @@ _again:
while ( __nacts-- > 0 ) {
switch ( *__acts++ ) {
case 0:
-#line 2559 "upb/json/parser.rl"
+#line 2555 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; if ( p == pe )
goto _test_eof;
goto _again;} }
break;
- case 35:
-#line 2710 "upb/json/parser.rl"
+ case 46:
+#line 2729 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_number(parser, p)); }
break;
- case 38:
-#line 2715 "upb/json/parser.rl"
+ case 49:
+#line 2734 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_bool(parser, true)); }
break;
- case 39:
-#line 2717 "upb/json/parser.rl"
+ case 50:
+#line 2736 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_bool(parser, false)); }
break;
- case 40:
-#line 2719 "upb/json/parser.rl"
+ case 51:
+#line 2738 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_null(parser)); }
break;
- case 42:
-#line 2722 "upb/json/parser.rl"
+ case 53:
+#line 2741 "upb/json/parser.rl"
{ end_subobject_full(parser); }
break;
-#line 3153 "upb/json/parser.c"
+#line 3196 "upb/json/parser.c"
}
}
}
@@ -3157,11 +3200,10 @@ goto _again;} }
_out: {}
}
-#line 2755 "upb/json/parser.rl"
+#line 2774 "upb/json/parser.rl"
if (p != pe) {
- upb_status_seterrf(&parser->status, "Parse error at '%.*s'\n", pe - p, p);
- upb_env_reporterror(parser->env, &parser->status);
+ upb_status_seterrf(parser->status, "Parse error at '%.*s'\n", pe - p, p);
} else {
capture_suspend(parser, &p);
}
@@ -3197,132 +3239,95 @@ static void json_parser_reset(upb_json_parser *p) {
int top;
p->top = p->stack;
- p->top->f = NULL;
- p->top->is_map = false;
- p->top->is_mapentry = false;
- p->top->is_any = false;
- p->top->any_frame = NULL;
- p->top->is_unknown_field = false;
+ init_frame(p->top);
/* Emit Ragel initialization of the parser. */
-#line 3210 "upb/json/parser.c"
+#line 3247 "upb/json/parser.c"
{
cs = json_start;
top = 0;
}
-#line 2803 "upb/json/parser.rl"
+#line 2816 "upb/json/parser.rl"
p->current_state = cs;
p->parser_top = top;
accumulate_clear(p);
p->multipart_state = MULTIPART_INACTIVE;
p->capture = NULL;
p->accumulated = NULL;
- upb_status_clear(&p->status);
-}
-
-static void visit_json_parsermethod(const upb_refcounted *r,
- upb_refcounted_visit *visit,
- void *closure) {
- const upb_json_parsermethod *method = (upb_json_parsermethod*)r;
- visit(r, upb_msgdef_upcast2(method->msg), closure);
}
-static void free_json_parsermethod(upb_refcounted *r) {
- upb_json_parsermethod *method = (upb_json_parsermethod*)r;
-
- upb_inttable_iter i;
- upb_inttable_begin(&i, &method->name_tables);
- for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
- upb_value val = upb_inttable_iter_value(&i);
- upb_strtable *t = upb_value_getptr(val);
- upb_strtable_uninit(t);
- upb_gfree(t);
- }
+static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
+ const upb_msgdef *md) {
+ upb_msg_field_iter i;
+ upb_alloc *alloc = upb_arena_alloc(c->arena);
- upb_inttable_uninit(&method->name_tables);
+ upb_json_parsermethod *m = upb_malloc(alloc, sizeof(*m));
- upb_gfree(r);
-}
+ m->cache = c;
-static void add_jsonname_table(upb_json_parsermethod *m, const upb_msgdef* md) {
- upb_msg_field_iter i;
- upb_strtable *t;
+ upb_byteshandler_init(&m->input_handler_);
+ upb_byteshandler_setstring(&m->input_handler_, parse, m);
+ upb_byteshandler_setendstr(&m->input_handler_, end, m);
- /* It would be nice to stack-allocate this, but protobufs do not limit the
- * length of fields to any reasonable limit. */
- char *buf = NULL;
- size_t len = 0;
-
- if (upb_inttable_lookupptr(&m->name_tables, md, NULL)) {
- return;
- }
+ upb_strtable_init2(&m->name_table, UPB_CTYPE_CONSTPTR, alloc);
- /* TODO(haberman): handle malloc failure. */
- t = upb_gmalloc(sizeof(*t));
- upb_strtable_init(t, UPB_CTYPE_CONSTPTR);
- upb_inttable_insertptr(&m->name_tables, md, upb_value_ptr(t));
+ /* Build name_table */
for(upb_msg_field_begin(&i, md);
!upb_msg_field_done(&i);
upb_msg_field_next(&i)) {
const upb_fielddef *f = upb_msg_iter_field(&i);
+ upb_value v = upb_value_constptr(f);
+ char *buf;
/* Add an entry for the JSON name. */
- size_t field_len = upb_fielddef_getjsonname(f, buf, len);
- if (field_len > len) {
- size_t len2;
- buf = upb_grealloc(buf, 0, field_len);
- len = field_len;
- len2 = upb_fielddef_getjsonname(f, buf, len);
- UPB_ASSERT(len == len2);
- }
- upb_strtable_insert(t, buf, upb_value_constptr(f));
+ size_t len = upb_fielddef_getjsonname(f, NULL, 0);
+ buf = upb_malloc(alloc, len);
+ upb_fielddef_getjsonname(f, buf, len);
+ upb_strtable_insert3(&m->name_table, buf, strlen(buf), v, alloc);
if (strcmp(buf, upb_fielddef_name(f)) != 0) {
/* Since the JSON name is different from the regular field name, add an
* entry for the raw name (compliant proto3 JSON parsers must accept
* both). */
- upb_strtable_insert(t, upb_fielddef_name(f), upb_value_constptr(f));
- }
-
- if (upb_fielddef_issubmsg(f)) {
- add_jsonname_table(m, upb_fielddef_msgsubdef(f));
+ const char *name = upb_fielddef_name(f);
+ upb_strtable_insert3(&m->name_table, name, strlen(name), v, alloc);
}
}
- upb_gfree(buf);
+ return m;
}
/* Public API *****************************************************************/
-upb_json_parser *upb_json_parser_create(upb_env *env,
+upb_json_parser *upb_json_parser_create(upb_arena *arena,
const upb_json_parsermethod *method,
const upb_symtab* symtab,
- upb_sink *output,
+ upb_sink output,
+ upb_status *status,
bool ignore_json_unknown) {
#ifndef NDEBUG
- const size_t size_before = upb_env_bytesallocated(env);
+ const size_t size_before = upb_arena_bytesallocated(arena);
#endif
- upb_json_parser *p = upb_env_malloc(env, sizeof(upb_json_parser));
+ upb_json_parser *p = upb_arena_malloc(arena, sizeof(upb_json_parser));
if (!p) return false;
- p->env = env;
+ p->arena = arena;
p->method = method;
+ p->status = status;
p->limit = p->stack + UPB_JSON_MAX_DEPTH;
p->accumulate_buf = NULL;
p->accumulate_buf_size = 0;
upb_bytessink_reset(&p->input_, &method->input_handler_, p);
json_parser_reset(p);
- upb_sink_reset(&p->top->sink, output->handlers, output->closure);
- p->top->m = upb_handlers_msgdef(output->handlers);
+ p->top->sink = output;
+ p->top->m = upb_handlers_msgdef(output.handlers);
if (is_wellknown_msg(p, UPB_WELLKNOWN_ANY)) {
p->top->is_any = true;
- p->top->any_frame =
- upb_env_malloc(p->env, sizeof(upb_jsonparser_any_frame));
- json_parser_any_frame_reset(p->top->any_frame);
+ p->top->any_frame = json_parser_any_frame_new(p);
} else {
p->top->is_any = false;
p->top->any_frame = NULL;
@@ -3333,38 +3338,72 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
p->ignore_json_unknown = ignore_json_unknown;
/* If this fails, uncomment and increase the value in parser.h. */
- /* fprintf(stderr, "%zd\n", upb_env_bytesallocated(env) - size_before); */
- UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(env) - size_before <=
+ /* fprintf(stderr, "%zd\n", upb_arena_bytesallocated(arena) - size_before); */
+ UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(arena) - size_before <=
UPB_JSON_PARSER_SIZE);
return p;
}
-upb_bytessink *upb_json_parser_input(upb_json_parser *p) {
- return &p->input_;
+upb_bytessink upb_json_parser_input(upb_json_parser *p) {
+ return p->input_;
}
-upb_json_parsermethod *upb_json_parsermethod_new(const upb_msgdef* md,
- const void* owner) {
- static const struct upb_refcounted_vtbl vtbl = {visit_json_parsermethod,
- free_json_parsermethod};
- upb_json_parsermethod *ret = upb_gmalloc(sizeof(*ret));
- upb_refcounted_init(upb_json_parsermethod_upcast_mutable(ret), &vtbl, owner);
+const upb_byteshandler *upb_json_parsermethod_inputhandler(
+ const upb_json_parsermethod *m) {
+ return &m->input_handler_;
+}
- ret->msg = md;
- upb_ref2(md, ret);
+upb_json_codecache *upb_json_codecache_new() {
+ upb_alloc *alloc;
+ upb_json_codecache *c;
- upb_byteshandler_init(&ret->input_handler_);
- upb_byteshandler_setstring(&ret->input_handler_, parse, ret);
- upb_byteshandler_setendstr(&ret->input_handler_, end, ret);
+ c = upb_gmalloc(sizeof(*c));
- upb_inttable_init(&ret->name_tables, UPB_CTYPE_PTR);
+ c->arena = upb_arena_new();
+ alloc = upb_arena_alloc(c->arena);
- add_jsonname_table(ret, md);
+ upb_inttable_init2(&c->methods, UPB_CTYPE_CONSTPTR, alloc);
- return ret;
+ return c;
}
-const upb_byteshandler *upb_json_parsermethod_inputhandler(
- const upb_json_parsermethod *m) {
- return &m->input_handler_;
+void upb_json_codecache_free(upb_json_codecache *c) {
+ upb_arena_free(c->arena);
+ upb_gfree(c);
+}
+
+const upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
+ const upb_msgdef *md) {
+ upb_json_parsermethod *m;
+ upb_value v;
+ upb_msg_field_iter i;
+ upb_alloc *alloc = upb_arena_alloc(c->arena);
+
+ if (upb_inttable_lookupptr(&c->methods, md, &v)) {
+ return upb_value_getconstptr(v);
+ }
+
+ m = parsermethod_new(c, md);
+ v = upb_value_constptr(m);
+
+ if (!m) return NULL;
+ if (!upb_inttable_insertptr2(&c->methods, md, v, alloc)) return NULL;
+
+ /* Populate parser methods for all submessages, so the name tables will
+ * be available during parsing. */
+ for(upb_msg_field_begin(&i, md);
+ !upb_msg_field_done(&i);
+ upb_msg_field_next(&i)) {
+ upb_fielddef *f = upb_msg_iter_field(&i);
+
+ if (upb_fielddef_issubmsg(f)) {
+ const upb_msgdef *subdef = upb_fielddef_msgsubdef(f);
+ const upb_json_parsermethod *sub_method =
+ upb_json_codecache_get(c, subdef);
+
+ if (!sub_method) return NULL;
+ }
+ }
+
+ return m;
}
generated by cgit on debian on lair
contact matthew@masot.net with questions or feedback