summaryrefslogtreecommitdiff
path: root/upb/json/parser.rl
diff options
context:
space:
mode:
Diffstat (limited to 'upb/json/parser.rl')
-rw-r--r--upb/json/parser.rl153
1 files changed, 56 insertions, 97 deletions
diff --git a/upb/json/parser.rl b/upb/json/parser.rl
index 05a9505..a117d0c 100644
--- a/upb/json/parser.rl
+++ b/upb/json/parser.rl
@@ -210,7 +210,7 @@ typedef struct {
} upb_jsonparser_frame;
struct upb_json_parser {
- upb_env *env;
+ upb_arena *arena;
const upb_json_parsermethod *method;
upb_bytessink input_;
@@ -219,7 +219,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;
@@ -257,7 +257,7 @@ struct upb_json_parser {
};
struct upb_json_codecache {
- upb_arena arena;
+ upb_arena *arena;
upb_inttable methods; /* upb_msgdef* -> upb_json_parsermethod* */
};
@@ -275,7 +275,7 @@ static upb_jsonparser_any_frame *json_parser_any_frame_new(
upb_json_parser *p) {
upb_jsonparser_any_frame *frame;
- frame = upb_env_malloc(p->env, sizeof(upb_jsonparser_any_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();
@@ -299,12 +299,12 @@ static void json_parser_any_frame_set_payload_type(
/* Initialize encoder. */
h = upb_handlercache_get(frame->encoder_handlercache, payload_type);
- encoder = upb_pb_encoder_create(p->env, h, frame->stringsink.sink);
+ encoder = upb_pb_encoder_create(p->arena, h, frame->stringsink.sink);
/* Initialize parser. */
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, parser_method, p->symtab,
+ frame->parser = upb_json_parser_create(p->arena, parser_method, p->symtab,
frame->sink, p->ignore_json_unknown);
}
@@ -370,8 +370,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;
}
@@ -466,10 +465,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;
}
@@ -493,10 +491,9 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
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;
@@ -534,11 +531,10 @@ otherchar:
}
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 +578,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 +603,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 +681,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:
@@ -1053,8 +1046,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,10 +1060,9 @@ 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;
}
@@ -1246,10 +1237,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;
}
}
@@ -1282,8 +1272,7 @@ 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;
}
@@ -1292,8 +1281,7 @@ static bool end_any_stringval(upb_json_parser *p) {
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;
}
}
@@ -1345,8 +1333,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
upb_selector_t sel = parser_getsel(p);
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;
@@ -1363,8 +1350,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;
}
@@ -1443,25 +1429,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;
}
@@ -1470,9 +1453,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;
}
@@ -1498,7 +1480,7 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
end_member(p);
- /* Continue previous environment */
+ /* Continue previous arena */
multipart_startaccum(p);
return true;
@@ -1528,8 +1510,7 @@ static bool end_timestamp_base(upb_json_parser *p, const char *ptr) {
/* 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);
+ upb_status_seterrf(p->status, "error parsing timestamp: %s", buf);
return false;
}
@@ -1562,9 +1543,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;
}
@@ -1574,9 +1554,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;
}
@@ -1618,8 +1597,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;
}
@@ -1635,10 +1613,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;
}
@@ -1679,8 +1656,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)) {
@@ -1703,9 +1679,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);
@@ -1723,8 +1698,7 @@ static bool parse_mapentry_key(upb_json_parser *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;
}
@@ -1783,8 +1757,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;
}
@@ -1819,8 +1792,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;
}
}
@@ -1846,14 +1818,13 @@ 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. */
@@ -1947,10 +1918,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;
}
}
@@ -2058,10 +2028,9 @@ 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;
}
@@ -2120,12 +2089,7 @@ static void start_object(upb_json_parser *p) {
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);
}
}
@@ -2144,8 +2108,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;
}
@@ -2160,8 +2123,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++;
@@ -2173,8 +2135,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++;
@@ -2247,7 +2208,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;
}
@@ -2605,8 +2565,7 @@ size_t parse(void *closure, const void *hd, const char *buf, size_t size,
%% write exec;
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);
}
@@ -2656,13 +2615,12 @@ static void json_parser_reset(upb_json_parser *p) {
p->multipart_state = MULTIPART_INACTIVE;
p->capture = NULL;
p->accumulated = NULL;
- upb_status_clear(&p->status);
}
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_alloc *alloc = upb_arena_alloc(c->arena);
upb_json_parsermethod *m = upb_malloc(alloc, sizeof(*m));
@@ -2703,19 +2661,20 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
/* 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,
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 = NULL;
p->limit = p->stack + UPB_JSON_MAX_DEPTH;
p->accumulate_buf = NULL;
p->accumulate_buf_size = 0;
@@ -2737,8 +2696,8 @@ 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;
}
@@ -2758,8 +2717,8 @@ upb_json_codecache *upb_json_codecache_new() {
c = upb_gmalloc(sizeof(*c));
- upb_arena_init(&c->arena);
- alloc = upb_arena_alloc(&c->arena);
+ c->arena = upb_arena_new();
+ alloc = upb_arena_alloc(c->arena);
upb_inttable_init2(&c->methods, UPB_CTYPE_CONSTPTR, alloc);
@@ -2767,7 +2726,7 @@ upb_json_codecache *upb_json_codecache_new() {
}
void upb_json_codecache_free(upb_json_codecache *c) {
- upb_arena_uninit(&c->arena);
+ upb_arena_free(c->arena);
upb_gfree(c);
}
@@ -2776,7 +2735,7 @@ const upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
upb_json_parsermethod *m;
upb_value v;
upb_msg_field_iter i;
- upb_alloc *alloc = upb_arena_alloc(&c->arena);
+ upb_alloc *alloc = upb_arena_alloc(c->arena);
if (upb_inttable_lookupptr(&c->methods, md, &v)) {
return upb_value_getconstptr(v);
generated by cgit on debian on lair
contact matthew@masot.net with questions or feedback