Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into maps

Browse Source
pull/13171/head
Joshua Haberman 5 years ago
parent 18de110b00 56589c7276
commit 946880c105
35 changed files with 371 additions and 258 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 120
      BUILD
  2. 1
      CMakeLists.txt
  3. 6
      bazel/build_defs.bzl
  4. 26
      bazel/upb_proto_library.bzl
  5. 151
      generated_for_cmake/upb/json/parser.c
  6. 4
      tests/conformance_upb.c
  7. 1
      tests/corpus/README
  8. 1
      tests/corpus/temp.cc
  9. 10
      tests/pb/test_decoder.cc
  10. 2
      tests/pb/test_varint.c
  11. 18
      upb/decode.c
  12. 3
      upb/def.c
  13. 2
      upb/def.h
  14. 8
      upb/encode.c
  15. 4
      upb/generated_util.h
  16. 2
      upb/json/parser.h
  17. 13
      upb/json/parser.rl
  18. 45
      upb/json/printer.c
  19. 2
      upb/legacy_msg_reflection.c
  20. 2
      upb/legacy_msg_reflection.h
  21. 2
      upb/msg.c
  22. 40
      upb/pb/compile_decoder.c
  23. 29
      upb/pb/decoder.c
  24. 24
      upb/pb/decoder.int.h
  25. 2
      upb/pb/encoder.c
  26. 2
      upb/pb/encoder.h
  27. 2
      upb/pb/textprinter.c
  28. 2
      upb/pb/textprinter.h
  29. 8
      upb/pb/varint.int.h
  30. 27
      upb/port.c
  31. 35
      upb/port_def.inc
  32. 2
      upb/port_undef.inc
  33. 19
      upb/table.c
  34. 2
      upb/table.int.h
  35. 12
      upb/upb.h

120
BUILD
Unescape View File

@ -9,7 +9,6 @@ load(
"make_shell_script", "make_shell_script",
"upb_amalgamation", "upb_amalgamation",
) )
load( load(
"//bazel:upb_proto_library.bzl", "//bazel:upb_proto_library.bzl",
"upb_proto_library", "upb_proto_library",
@ -33,7 +32,7 @@ CPPOPTS = [
COPTS = CPPOPTS + [ COPTS = CPPOPTS + [
# copybara:strip_for_google3_begin # copybara:strip_for_google3_begin
"-pedantic", "-pedantic",
"-std=c89", "-Wstrict-prototypes",
# copybara:strip_end # copybara:strip_end
] ]
@ -43,6 +42,11 @@ config_setting(
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
) )
config_setting(
name = "windows",
constraint_values = ["@bazel_tools//platforms:windows"],
)
config_setting( config_setting(
name = "fuzz", name = "fuzz",
values = {"define": "fuzz=true"}, values = {"define": "fuzz=true"},
@ -58,6 +62,7 @@ cc_library(
"upb/generated_util.h", "upb/generated_util.h",
"upb/msg.c", "upb/msg.c",
"upb/msg.h", "upb/msg.h",
"upb/port.c",
"upb/port_def.inc", "upb/port_def.inc",
"upb/port_undef.inc", "upb/port_undef.inc",
"upb/table.c", "upb/table.c",
@ -69,7 +74,10 @@ cc_library(
"upb/encode.h", "upb/encode.h",
"upb/upb.h", "upb/upb.h",
], ],
copts = COPTS, copts = select({
":windows": [],
"//conditions:default": COPTS
}),
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
) )
@ -81,23 +89,26 @@ cc_library(
# give up any backward compatibility guarantees. # give up any backward compatibility guarantees.
cc_library( cc_library(
name = "generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me", name = "generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me",
textual_hdrs = [
"upb/port_def.inc",
"upb/port_undef.inc",
],
hdrs = [ hdrs = [
"upb/generated_util.h", "upb/generated_util.h",
"upb/msg.h", "upb/msg.h",
], ],
deps = [":upb"], copts = select({
copts = COPTS, ":windows": [],
"//conditions:default": COPTS
}),
textual_hdrs = [
"upb/port_def.inc",
"upb/port_undef.inc",
],
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
deps = [":upb"],
) )
upb_proto_library( upb_proto_library(
name = "descriptor_upbproto", name = "descriptor_upbproto",
deps = ["@com_google_protobuf//:descriptor_proto"],
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
deps = ["@com_google_protobuf//:descriptor_proto"],
) )
cc_library( cc_library(
@ -110,7 +121,10 @@ cc_library(
"upb/def.h", "upb/def.h",
"upb/msgfactory.h", "upb/msgfactory.h",
], ],
copts = COPTS, copts = select({
":windows": [],
"//conditions:default": COPTS
}),
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
deps = [ deps = [
":descriptor_upbproto", ":descriptor_upbproto",
@ -135,7 +149,10 @@ cc_library(
"upb/legacy_msg_reflection.c", "upb/legacy_msg_reflection.c",
], ],
hdrs = ["upb/legacy_msg_reflection.h"], hdrs = ["upb/legacy_msg_reflection.h"],
copts = COPTS, copts = select({
":windows": [],
"//conditions:default": COPTS
}),
deps = [ deps = [
":table", ":table",
":upb", ":upb",
@ -153,7 +170,10 @@ cc_library(
"upb/handlers.h", "upb/handlers.h",
"upb/sink.h", "upb/sink.h",
], ],
copts = COPTS, copts = select({
":windows": [],
"//conditions:default": COPTS
}),
deps = [ deps = [
":reflection", ":reflection",
":table", ":table",
@ -177,7 +197,10 @@ cc_library(
"upb/pb/encoder.h", "upb/pb/encoder.h",
"upb/pb/textprinter.h", "upb/pb/textprinter.h",
], ],
copts = COPTS, copts = select({
":windows": [],
"//conditions:default": COPTS
}),
deps = [ deps = [
":descriptor_upbproto", ":descriptor_upbproto",
":handlers", ":handlers",
@ -198,7 +221,10 @@ cc_library(
"upb/json/parser.h", "upb/json/parser.h",
"upb/json/printer.h", "upb/json/printer.h",
], ],
copts = COPTS, copts = select({
":windows": [],
"//conditions:default": COPTS
}),
deps = [ deps = [
":upb", ":upb",
":upb_pb", ":upb_pb",
@ -228,7 +254,10 @@ cc_library(
"upbc/message_layout.h", "upbc/message_layout.h",
], ],
hdrs = ["upbc/generator.h"], hdrs = ["upbc/generator.h"],
copts = CPPOPTS, copts = select({
":windows": [],
"//conditions:default": CPPOPTS
}),
deps = [ deps = [
"@absl//absl/base:core_headers", "@absl//absl/base:core_headers",
"@absl//absl/container:flat_hash_map", "@absl//absl/container:flat_hash_map",
@ -241,7 +270,10 @@ cc_library(
cc_binary( cc_binary(
name = "protoc-gen-upb", name = "protoc-gen-upb",
srcs = ["upbc/main.cc"], srcs = ["upbc/main.cc"],
copts = CPPOPTS, copts = select({
":windows": [],
"//conditions:default": CPPOPTS
}),
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
deps = [ deps = [
":upbc_generator", ":upbc_generator",
@ -275,7 +307,10 @@ cc_library(
"tests/test_util.h", "tests/test_util.h",
"tests/upb_test.h", "tests/upb_test.h",
], ],
copts = CPPOPTS, copts = select({
":windows": [],
"//conditions:default": CPPOPTS
}),
deps = [ deps = [
":handlers", ":handlers",
":upb", ":upb",
@ -288,7 +323,10 @@ cc_test(
"tests/pb/test_varint.c", "tests/pb/test_varint.c",
"upb/pb/varint.int.h", "upb/pb/varint.int.h",
], ],
copts = COPTS, copts = select({
":windows": [],
"//conditions:default": COPTS
}),
deps = [ deps = [
":upb", ":upb",
":upb_pb", ":upb_pb",
@ -314,7 +352,10 @@ cc_test(
"tests/pb/test_decoder.cc", "tests/pb/test_decoder.cc",
"upb/pb/varint.int.h", "upb/pb/varint.int.h",
], ],
copts = CPPOPTS, copts = select({
":windows": [],
"//conditions:default": CPPOPTS
}),
deps = [ deps = [
":handlers", ":handlers",
":test_decoder_upbproto", ":test_decoder_upbproto",
@ -339,7 +380,10 @@ upb_proto_reflection_library(
cc_test( cc_test(
name = "test_cpp", name = "test_cpp",
srcs = ["tests/test_cpp.cc"], srcs = ["tests/test_cpp.cc"],
copts = CPPOPTS, copts = select({
":windows": [],
"//conditions:default": CPPOPTS
}),
deps = [ deps = [
":handlers", ":handlers",
":reflection", ":reflection",
@ -353,7 +397,10 @@ cc_test(
cc_test( cc_test(
name = "test_table", name = "test_table",
srcs = ["tests/test_table.cc"], srcs = ["tests/test_table.cc"],
copts = CPPOPTS, copts = select({
":windows": [],
"//conditions:default": CPPOPTS
}),
deps = [ deps = [
":table", ":table",
":upb", ":upb",
@ -363,12 +410,15 @@ cc_test(
# OSS-Fuzz test # OSS-Fuzz test
cc_binary( cc_binary(
testonly = 1,
name = "file_descriptor_parsenew_fuzzer", name = "file_descriptor_parsenew_fuzzer",
testonly = 1,
srcs = ["tests/file_descriptor_parsenew_fuzzer.cc"], srcs = ["tests/file_descriptor_parsenew_fuzzer.cc"],
copts = CPPOPTS + select({ copts = select({
":windows": [],
"//conditions:default": CPPOPTS
}) + select({
"//conditions:default": [], "//conditions:default": [],
":fuzz": ["-fsanitizer=fuzzer,address"], ":fuzz": ["-fsanitize=fuzzer,address"],
}), }),
defines = select({ defines = select({
"//conditions:default": [], "//conditions:default": [],
@ -389,7 +439,10 @@ upb_proto_reflection_library(
cc_test( cc_test(
name = "test_encoder", name = "test_encoder",
srcs = ["tests/pb/test_encoder.cc"], srcs = ["tests/pb/test_encoder.cc"],
copts = CPPOPTS, copts = select({
":windows": [],
"//conditions:default": CPPOPTS
}),
deps = [ deps = [
":descriptor_upbproto", ":descriptor_upbproto",
":descriptor_upbreflection", ":descriptor_upbreflection",
@ -431,7 +484,10 @@ cc_test(
srcs = [ srcs = [
"tests/json/test_json.cc", "tests/json/test_json.cc",
], ],
copts = CPPOPTS, copts = select({
":windows": [],
"//conditions:default": CPPOPTS
}),
deps = [ deps = [
":test_json_upbproto", ":test_json_upbproto",
":test_json_upbprotoreflection", ":test_json_upbprotoreflection",
@ -459,7 +515,10 @@ cc_binary(
srcs = [ srcs = [
"tests/conformance_upb.c", "tests/conformance_upb.c",
], ],
copts = COPTS + ["-Ibazel-out/k8-fastbuild/bin"], copts = select({
":windows": [],
"//conditions:default": COPTS
}) + ["-Ibazel-out/k8-fastbuild/bin"],
deps = [ deps = [
":conformance_proto_upb", ":conformance_proto_upb",
":test_messages_proto3_proto_upb", ":test_messages_proto3_proto_upb",
@ -513,7 +572,10 @@ cc_library(
name = "amalgamation", name = "amalgamation",
srcs = ["upb.c"], srcs = ["upb.c"],
hdrs = ["upb.h"], hdrs = ["upb.h"],
copts = COPTS, copts = select({
":windows": [],
"//conditions:default": COPTS
}),
) )
# Lua libraries. ############################################################### # Lua libraries. ###############################################################

1
CMakeLists.txt
Unescape View File

@ -66,6 +66,7 @@ add_library(upb
upb/generated_util.h upb/generated_util.h
upb/msg.c upb/msg.c
upb/msg.h upb/msg.h
upb/port.c
upb/port_def.inc upb/port_def.inc
upb/port_undef.inc upb/port_undef.inc
upb/table.c upb/table.c

6
bazel/build_defs.bzl
Unescape View File

@ -1,6 +1,6 @@
"""Internal rules for building upb.""" """Internal rules for building upb."""
load(":upb_proto_library.bzl", "GeneratedSrcs") load(":upb_proto_library.bzl", "GeneratedSrcsInfo")
def _librule(name): def _librule(name):
return name + "_lib" return name + "_lib"
@ -173,8 +173,8 @@ SrcList = provider(
) )
def _file_list_aspect_impl(target, ctx): def _file_list_aspect_impl(target, ctx):
if GeneratedSrcs in target: if GeneratedSrcsInfo in target:
srcs = target[GeneratedSrcs] srcs = target[GeneratedSrcsInfo]
return [SrcList(srcs = srcs.srcs + srcs.hdrs)] return [SrcList(srcs = srcs.srcs + srcs.hdrs)]
srcs = [] srcs = []

26
bazel/upb_proto_library.bzl
Unescape View File

@ -22,6 +22,11 @@ def _get_real_short_path(file):
if short_path.startswith("../"): if short_path.startswith("../"):
second_slash = short_path.index("/", 3) second_slash = short_path.index("/", 3)
short_path = short_path[second_slash + 1:] short_path = short_path[second_slash + 1:]
# Sometimes it has another few prefixes like:
# _virtual_imports/any_proto/google/protobuf/any.proto
# We want just google/protobuf/any.proto.
if short_path.startswith("_virtual_imports"):
short_path = short_path.split("/", 2)[-1]
return short_path return short_path
def _get_real_root(file): def _get_real_root(file):
@ -134,7 +139,7 @@ def _cc_library_func(ctx, name, hdrs, srcs, dep_ccinfos):
# upb_proto_library / upb_proto_reflection_library shared code ################# # upb_proto_library / upb_proto_reflection_library shared code #################
GeneratedSrcs = provider( GeneratedSrcsInfo = provider(
fields = { fields = {
"srcs": "list of srcs", "srcs": "list of srcs",
"hdrs": "list of hdrs", "hdrs": "list of hdrs",
@ -142,7 +147,7 @@ GeneratedSrcs = provider(
) )
_WrappedCcInfo = provider(fields = ["cc_info"]) _WrappedCcInfo = provider(fields = ["cc_info"])
_WrappedGeneratedSrcs = provider(fields = ["srcs"]) _WrappedGeneratedSrcsInfo = provider(fields = ["srcs"])
def _compile_upb_protos(ctx, proto_info, proto_sources, ext): def _compile_upb_protos(ctx, proto_info, proto_sources, ext):
srcs = [_generate_output_file(ctx, name, ext + ".c") for name in proto_sources] srcs = [_generate_output_file(ctx, name, ext + ".c") for name in proto_sources]
@ -159,23 +164,26 @@ def _compile_upb_protos(ctx, proto_info, proto_sources, ext):
arguments = [ arguments = [
"--upb_out=" + _get_real_root(srcs[0]), "--upb_out=" + _get_real_root(srcs[0]),
"--plugin=protoc-gen-upb=" + ctx.executable._upbc.path, "--plugin=protoc-gen-upb=" + ctx.executable._upbc.path,
"--descriptor_set_in=" + ":".join([f.path for f in transitive_sets]), "--descriptor_set_in=" + ctx.configuration.host_path_separator.join([f.path for f in transitive_sets]),
] + ] +
[_get_real_short_path(file) for file in proto_sources], [_get_real_short_path(file) for file in proto_sources],
progress_message = "Generating upb protos for :" + ctx.label.name, progress_message = "Generating upb protos for :" + ctx.label.name,
) )
return GeneratedSrcs(srcs = srcs, hdrs = hdrs) return GeneratedSrcsInfo(srcs = srcs, hdrs = hdrs)
def _upb_proto_rule_impl(ctx): def _upb_proto_rule_impl(ctx):
if len(ctx.attr.deps) != 1: if len(ctx.attr.deps) != 1:
fail("only one deps dependency allowed.") fail("only one deps dependency allowed.")
dep = ctx.attr.deps[0] dep = ctx.attr.deps[0]
if _WrappedCcInfo not in dep or _WrappedGeneratedSrcs not in dep: if _WrappedCcInfo not in dep or _WrappedGeneratedSrcsInfo not in dep:
fail("proto_library rule must generate _WrappedCcInfo and " + fail("proto_library rule must generate _WrappedCcInfo and " +
"_WrappedGeneratedSrcs (aspect should have handled this).") "_WrappedGeneratedSrcsInfo (aspect should have handled this).")
cc_info = dep[_WrappedCcInfo].cc_info cc_info = dep[_WrappedCcInfo].cc_info
srcs = dep[_WrappedGeneratedSrcs].srcs srcs = dep[_WrappedGeneratedSrcsInfo].srcs
lib = cc_info.linking_context.libraries_to_link.to_list()[0] if type(cc_info.linking_context.libraries_to_link) == "list":
lib = cc_info.linking_context.libraries_to_link[0]
else:
lib = cc_info.linking_context.libraries_to_link.to_list()[0]
files = _filter_none([ files = _filter_none([
lib.static_library, lib.static_library,
lib.pic_static_library, lib.pic_static_library,
@ -200,7 +208,7 @@ def _upb_proto_aspect_impl(target, ctx):
srcs = files.srcs, srcs = files.srcs,
dep_ccinfos = dep_ccinfos, dep_ccinfos = dep_ccinfos,
) )
return [_WrappedCcInfo(cc_info = cc_info), _WrappedGeneratedSrcs(srcs = files)] return [_WrappedCcInfo(cc_info = cc_info), _WrappedGeneratedSrcsInfo(srcs = files)]
def _maybe_add(d): def _maybe_add(d):
if not _is_bazel: if not _is_bazel:

151
generated_for_cmake/upb/json/parser.c
Unescape View File

@ -949,7 +949,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
upb_fieldtype_t type = upb_fielddef_type(p->top->f); upb_fieldtype_t type = upb_fielddef_type(p->top->f);
double val; double val;
double dummy; double dummy;
double inf = 1.0 / 0.0; /* C89 does not have an INFINITY macro. */ double inf = UPB_INFINITY;
errno = 0; errno = 0;
@ -1191,7 +1191,8 @@ static bool start_any_stringval(upb_json_parser *p) {
static bool start_stringval(upb_json_parser *p) { static bool start_stringval(upb_json_parser *p) {
if (is_top_level(p)) { if (is_top_level(p)) {
if (is_string_wrapper_object(p)) { if (is_string_wrapper_object(p) ||
is_number_wrapper_object(p)) {
start_wrapper_object(p); start_wrapper_object(p);
} else if (is_wellknown_msg(p, UPB_WELLKNOWN_FIELDMASK)) { } else if (is_wellknown_msg(p, UPB_WELLKNOWN_FIELDMASK)) {
start_fieldmask_object(p); start_fieldmask_object(p);
@ -1204,7 +1205,8 @@ static bool start_stringval(upb_json_parser *p) {
} else { } else {
return false; return false;
} }
} else if (does_string_wrapper_start(p)) { } else if (does_string_wrapper_start(p) ||
does_number_wrapper_start(p)) {
if (!start_subobject(p)) { if (!start_subobject(p)) {
return false; return false;
} }
@ -1410,7 +1412,8 @@ static bool end_stringval(upb_json_parser *p) {
return false; return false;
} }
if (does_string_wrapper_end(p)) { if (does_string_wrapper_end(p) ||
does_number_wrapper_end(p)) {
end_wrapper_object(p); end_wrapper_object(p);
if (!is_top_level(p)) { if (!is_top_level(p)) {
end_subobject(p); end_subobject(p);
@ -2586,11 +2589,11 @@ static bool does_fieldmask_end(upb_json_parser *p) {
* final state once, when the closing '"' is seen. */ * final state once, when the closing '"' is seen. */
#line 2791 "upb/json/parser.rl" #line 2794 "upb/json/parser.rl"
#line 2594 "upb/json/parser.c" #line 2597 "upb/json/parser.c"
static const char _json_actions[] = { static const char _json_actions[] = {
0, 1, 0, 1, 1, 1, 3, 1, 0, 1, 0, 1, 1, 1, 3, 1,
4, 1, 6, 1, 7, 1, 8, 1, 4, 1, 6, 1, 7, 1, 8, 1,
@ -2845,7 +2848,7 @@ static const int json_en_value_machine = 78;
static const int json_en_main = 1; static const int json_en_main = 1;
#line 2794 "upb/json/parser.rl" #line 2797 "upb/json/parser.rl"
size_t parse(void *closure, const void *hd, const char *buf, size_t size, size_t parse(void *closure, const void *hd, const char *buf, size_t size,
const upb_bufhandle *handle) { const upb_bufhandle *handle) {
@ -2868,7 +2871,7 @@ size_t parse(void *closure, const void *hd, const char *buf, size_t size,
capture_resume(parser, buf); capture_resume(parser, buf);
#line 2872 "upb/json/parser.c" #line 2875 "upb/json/parser.c"
{ {
int _klen; int _klen;
unsigned int _trans; unsigned int _trans;
@ -2943,147 +2946,147 @@ _match:
switch ( *_acts++ ) switch ( *_acts++ )
{ {
case 1: case 1:
#line 2599 "upb/json/parser.rl" #line 2602 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; goto _again;} } { p--; {cs = stack[--top]; goto _again;} }
break; break;
case 2: case 2:
#line 2601 "upb/json/parser.rl" #line 2604 "upb/json/parser.rl"
{ p--; {stack[top++] = cs; cs = 23;goto _again;} } { p--; {stack[top++] = cs; cs = 23;goto _again;} }
break; break;
case 3: case 3:
#line 2605 "upb/json/parser.rl" #line 2608 "upb/json/parser.rl"
{ start_text(parser, p); } { start_text(parser, p); }
break; break;
case 4: case 4:
#line 2606 "upb/json/parser.rl" #line 2609 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_text(parser, p)); } { CHECK_RETURN_TOP(end_text(parser, p)); }
break; break;
case 5: case 5:
#line 2612 "upb/json/parser.rl" #line 2615 "upb/json/parser.rl"
{ start_hex(parser); } { start_hex(parser); }
break; break;
case 6: case 6:
#line 2613 "upb/json/parser.rl" #line 2616 "upb/json/parser.rl"
{ hexdigit(parser, p); } { hexdigit(parser, p); }
break; break;
case 7: case 7:
#line 2614 "upb/json/parser.rl" #line 2617 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_hex(parser)); } { CHECK_RETURN_TOP(end_hex(parser)); }
break; break;
case 8: case 8:
#line 2620 "upb/json/parser.rl" #line 2623 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(escape(parser, p)); } { CHECK_RETURN_TOP(escape(parser, p)); }
break; break;
case 9: case 9:
#line 2626 "upb/json/parser.rl" #line 2629 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; goto _again;} } { p--; {cs = stack[--top]; goto _again;} }
break; break;
case 10: case 10:
#line 2631 "upb/json/parser.rl" #line 2634 "upb/json/parser.rl"
{ start_year(parser, p); } { start_year(parser, p); }
break; break;
case 11: case 11:
#line 2632 "upb/json/parser.rl" #line 2635 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_year(parser, p)); } { CHECK_RETURN_TOP(end_year(parser, p)); }
break; break;
case 12: case 12:
#line 2636 "upb/json/parser.rl" #line 2639 "upb/json/parser.rl"
{ start_month(parser, p); } { start_month(parser, p); }
break; break;
case 13: case 13:
#line 2637 "upb/json/parser.rl" #line 2640 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_month(parser, p)); } { CHECK_RETURN_TOP(end_month(parser, p)); }
break; break;
case 14: case 14:
#line 2641 "upb/json/parser.rl" #line 2644 "upb/json/parser.rl"
{ start_day(parser, p); } { start_day(parser, p); }
break; break;
case 15: case 15:
#line 2642 "upb/json/parser.rl" #line 2645 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_day(parser, p)); } { CHECK_RETURN_TOP(end_day(parser, p)); }
break; break;
case 16: case 16:
#line 2646 "upb/json/parser.rl" #line 2649 "upb/json/parser.rl"
{ start_hour(parser, p); } { start_hour(parser, p); }
break; break;
case 17: case 17:
#line 2647 "upb/json/parser.rl" #line 2650 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_hour(parser, p)); } { CHECK_RETURN_TOP(end_hour(parser, p)); }
break; break;
case 18: case 18:
#line 2651 "upb/json/parser.rl" #line 2654 "upb/json/parser.rl"
{ start_minute(parser, p); } { start_minute(parser, p); }
break; break;
case 19: case 19:
#line 2652 "upb/json/parser.rl" #line 2655 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_minute(parser, p)); } { CHECK_RETURN_TOP(end_minute(parser, p)); }
break; break;
case 20: case 20:
#line 2656 "upb/json/parser.rl" #line 2659 "upb/json/parser.rl"
{ start_second(parser, p); } { start_second(parser, p); }
break; break;
case 21: case 21:
#line 2657 "upb/json/parser.rl" #line 2660 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_second(parser, p)); } { CHECK_RETURN_TOP(end_second(parser, p)); }
break; break;
case 22: case 22:
#line 2662 "upb/json/parser.rl" #line 2665 "upb/json/parser.rl"
{ start_duration_base(parser, p); } { start_duration_base(parser, p); }
break; break;
case 23: case 23:
#line 2663 "upb/json/parser.rl" #line 2666 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_duration_base(parser, p)); } { CHECK_RETURN_TOP(end_duration_base(parser, p)); }
break; break;
case 24: case 24:
#line 2665 "upb/json/parser.rl" #line 2668 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; goto _again;} } { p--; {cs = stack[--top]; goto _again;} }
break; break;
case 25: case 25:
#line 2670 "upb/json/parser.rl" #line 2673 "upb/json/parser.rl"
{ start_timestamp_base(parser); } { start_timestamp_base(parser); }
break; break;
case 26: case 26:
#line 2672 "upb/json/parser.rl" #line 2675 "upb/json/parser.rl"
{ start_timestamp_fraction(parser, p); } { start_timestamp_fraction(parser, p); }
break; break;
case 27: case 27:
#line 2673 "upb/json/parser.rl" #line 2676 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_timestamp_fraction(parser, p)); } { CHECK_RETURN_TOP(end_timestamp_fraction(parser, p)); }
break; break;
case 28: case 28:
#line 2675 "upb/json/parser.rl" #line 2678 "upb/json/parser.rl"
{ start_timestamp_zone(parser, p); } { start_timestamp_zone(parser, p); }
break; break;
case 29: case 29:
#line 2676 "upb/json/parser.rl" #line 2679 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_timestamp_zone(parser, p)); } { CHECK_RETURN_TOP(end_timestamp_zone(parser, p)); }
break; break;
case 30: case 30:
#line 2678 "upb/json/parser.rl" #line 2681 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; goto _again;} } { p--; {cs = stack[--top]; goto _again;} }
break; break;
case 31: case 31:
#line 2683 "upb/json/parser.rl" #line 2686 "upb/json/parser.rl"
{ start_fieldmask_path_text(parser, p); } { start_fieldmask_path_text(parser, p); }
break; break;
case 32: case 32:
#line 2684 "upb/json/parser.rl" #line 2687 "upb/json/parser.rl"
{ end_fieldmask_path_text(parser, p); } { end_fieldmask_path_text(parser, p); }
break; break;
case 33: case 33:
#line 2689 "upb/json/parser.rl" #line 2692 "upb/json/parser.rl"
{ start_fieldmask_path(parser); } { start_fieldmask_path(parser); }
break; break;
case 34: case 34:
#line 2690 "upb/json/parser.rl" #line 2693 "upb/json/parser.rl"
{ end_fieldmask_path(parser); } { end_fieldmask_path(parser); }
break; break;
case 35: case 35:
#line 2696 "upb/json/parser.rl" #line 2699 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; goto _again;} } { p--; {cs = stack[--top]; goto _again;} }
break; break;
case 36: case 36:
#line 2701 "upb/json/parser.rl" #line 2704 "upb/json/parser.rl"
{ {
if (is_wellknown_msg(parser, UPB_WELLKNOWN_TIMESTAMP)) { if (is_wellknown_msg(parser, UPB_WELLKNOWN_TIMESTAMP)) {
{stack[top++] = cs; cs = 47;goto _again;} {stack[top++] = cs; cs = 47;goto _again;}
@ -3097,11 +3100,11 @@ _match:
} }
break; break;
case 37: case 37:
#line 2714 "upb/json/parser.rl" #line 2717 "upb/json/parser.rl"
{ p--; {stack[top++] = cs; cs = 78;goto _again;} } { p--; {stack[top++] = cs; cs = 78;goto _again;} }
break; break;
case 38: case 38:
#line 2719 "upb/json/parser.rl" #line 2722 "upb/json/parser.rl"
{ {
if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) { if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
start_any_member(parser, p); start_any_member(parser, p);
@ -3111,11 +3114,11 @@ _match:
} }
break; break;
case 39: case 39:
#line 2726 "upb/json/parser.rl" #line 2729 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_membername(parser)); } { CHECK_RETURN_TOP(end_membername(parser)); }
break; break;
case 40: case 40:
#line 2729 "upb/json/parser.rl" #line 2732 "upb/json/parser.rl"
{ {
if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) { if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
end_any_member(parser, p); end_any_member(parser, p);
@ -3125,7 +3128,7 @@ _match:
} }
break; break;
case 41: case 41:
#line 2740 "upb/json/parser.rl" #line 2743 "upb/json/parser.rl"
{ {
if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) { if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
start_any_object(parser, p); start_any_object(parser, p);
@ -3135,7 +3138,7 @@ _match:
} }
break; break;
case 42: case 42:
#line 2749 "upb/json/parser.rl" #line 2752 "upb/json/parser.rl"
{ {
if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) { if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
CHECK_RETURN_TOP(end_any_object(parser, p)); CHECK_RETURN_TOP(end_any_object(parser, p));
@ -3145,54 +3148,54 @@ _match:
} }
break; break;
case 43: case 43:
#line 2761 "upb/json/parser.rl" #line 2764 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(start_array(parser)); } { CHECK_RETURN_TOP(start_array(parser)); }
break; break;
case 44: case 44:
#line 2765 "upb/json/parser.rl" #line 2768 "upb/json/parser.rl"
{ end_array(parser); } { end_array(parser); }
break; break;
case 45: case 45:
#line 2770 "upb/json/parser.rl" #line 2773 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(start_number(parser, p)); } { CHECK_RETURN_TOP(start_number(parser, p)); }
break; break;
case 46: case 46:
#line 2771 "upb/json/parser.rl" #line 2774 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_number(parser, p)); } { CHECK_RETURN_TOP(end_number(parser, p)); }
break; break;
case 47: case 47:
#line 2773 "upb/json/parser.rl" #line 2776 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(start_stringval(parser)); } { CHECK_RETURN_TOP(start_stringval(parser)); }
break; break;
case 48: case 48:
#line 2774 "upb/json/parser.rl" #line 2777 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_stringval(parser)); } { CHECK_RETURN_TOP(end_stringval(parser)); }
break; break;
case 49: case 49:
#line 2776 "upb/json/parser.rl" #line 2779 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_bool(parser, true)); } { CHECK_RETURN_TOP(end_bool(parser, true)); }
break; break;
case 50: case 50:
#line 2778 "upb/json/parser.rl" #line 2781 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_bool(parser, false)); } { CHECK_RETURN_TOP(end_bool(parser, false)); }
break; break;
case 51: case 51:
#line 2780 "upb/json/parser.rl" #line 2783 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_null(parser)); } { CHECK_RETURN_TOP(end_null(parser)); }
break; break;
case 52: case 52:
#line 2782 "upb/json/parser.rl" #line 2785 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(start_subobject_full(parser)); } { CHECK_RETURN_TOP(start_subobject_full(parser)); }
break; break;
case 53: case 53:
#line 2783 "upb/json/parser.rl" #line 2786 "upb/json/parser.rl"
{ end_subobject_full(parser); } { end_subobject_full(parser); }
break; break;
case 54: case 54:
#line 2788 "upb/json/parser.rl" #line 2791 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; goto _again;} } { p--; {cs = stack[--top]; goto _again;} }
break; break;
#line 3196 "upb/json/parser.c" #line 3199 "upb/json/parser.c"
} }
} }
@ -3209,32 +3212,32 @@ _again:
while ( __nacts-- > 0 ) { while ( __nacts-- > 0 ) {
switch ( *__acts++ ) { switch ( *__acts++ ) {
case 0: case 0:
#line 2597 "upb/json/parser.rl" #line 2600 "upb/json/parser.rl"
{ p--; {cs = stack[--top]; if ( p == pe ) { p--; {cs = stack[--top]; if ( p == pe )
goto _test_eof; goto _test_eof;
goto _again;} } goto _again;} }
break; break;
case 46: case 46:
#line 2771 "upb/json/parser.rl" #line 2774 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_number(parser, p)); } { CHECK_RETURN_TOP(end_number(parser, p)); }
break; break;
case 49: case 49:
#line 2776 "upb/json/parser.rl" #line 2779 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_bool(parser, true)); } { CHECK_RETURN_TOP(end_bool(parser, true)); }
break; break;
case 50: case 50:
#line 2778 "upb/json/parser.rl" #line 2781 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_bool(parser, false)); } { CHECK_RETURN_TOP(end_bool(parser, false)); }
break; break;
case 51: case 51:
#line 2780 "upb/json/parser.rl" #line 2783 "upb/json/parser.rl"
{ CHECK_RETURN_TOP(end_null(parser)); } { CHECK_RETURN_TOP(end_null(parser)); }
break; break;
case 53: case 53:
#line 2783 "upb/json/parser.rl" #line 2786 "upb/json/parser.rl"
{ end_subobject_full(parser); } { end_subobject_full(parser); }
break; break;
#line 3238 "upb/json/parser.c" #line 3241 "upb/json/parser.c"
} }
} }
} }
@ -3242,7 +3245,7 @@ goto _again;} }
_out: {} _out: {}
} }
#line 2816 "upb/json/parser.rl" #line 2819 "upb/json/parser.rl"
if (p != pe) { if (p != pe) {
upb_status_seterrf(parser->status, "Parse error at '%.*s'\n", pe - p, p); upb_status_seterrf(parser->status, "Parse error at '%.*s'\n", pe - p, p);
@ -3285,13 +3288,13 @@ static void json_parser_reset(upb_json_parser *p) {
/* Emit Ragel initialization of the parser. */ /* Emit Ragel initialization of the parser. */
#line 3289 "upb/json/parser.c" #line 3292 "upb/json/parser.c"
{ {
cs = json_start; cs = json_start;
top = 0; top = 0;
} }
#line 2858 "upb/json/parser.rl" #line 2861 "upb/json/parser.rl"
p->current_state = cs; p->current_state = cs;
p->parser_top = top; p->parser_top = top;
accumulate_clear(p); accumulate_clear(p);
@ -3395,7 +3398,7 @@ const upb_byteshandler *upb_json_parsermethod_inputhandler(
return &m->input_handler_; return &m->input_handler_;
} }
upb_json_codecache *upb_json_codecache_new() { upb_json_codecache *upb_json_codecache_new(void) {
upb_alloc *alloc; upb_alloc *alloc;
upb_json_codecache *c; upb_json_codecache *c;

4
tests/conformance_upb.c
Unescape View File

@ -119,7 +119,7 @@ void DoTest(
return; return;
} }
bool DoTestIo() { bool DoTestIo(void) {
upb_arena *arena; upb_arena *arena;
upb_alloc *alloc; upb_alloc *alloc;
upb_status status; upb_status status;
@ -168,7 +168,7 @@ bool DoTestIo() {
return true; return true;
} }
int main() { int main(void) {
while (1) { while (1) {
if (!DoTestIo()) { if (!DoTestIo()) {
fprintf(stderr, "conformance_upb: received EOF from test runner " fprintf(stderr, "conformance_upb: received EOF from test runner "

1
tests/corpus/README
Unescape View File

@ -0,0 +1 @@
Corpus folder for fuzzing

1
tests/corpus/temp.cc
Unescape View File

@ -0,0 +1 @@
// Hello World

10
tests/pb/test_decoder.cc
Unescape View File

@ -447,12 +447,12 @@ upb::pb::DecoderPtr CreateDecoder(upb::Arena* arena,
uint32_t Hash(const string& proto, const string* expected_output, size_t seam1, uint32_t Hash(const string& proto, const string* expected_output, size_t seam1,
size_t seam2, bool may_skip) { size_t seam2, bool may_skip) {
uint32_t hash = MurmurHash2(proto.c_str(), proto.size(), 0); uint32_t hash = upb_murmur_hash2(proto.c_str(), proto.size(), 0);
if (expected_output) if (expected_output)
hash = MurmurHash2(expected_output->c_str(), expected_output->size(), hash); hash = upb_murmur_hash2(expected_output->c_str(), expected_output->size(), hash);
hash = MurmurHash2(&seam1, sizeof(seam1), hash); hash = upb_murmur_hash2(&seam1, sizeof(seam1), hash);
hash = MurmurHash2(&seam2, sizeof(seam2), hash); hash = upb_murmur_hash2(&seam2, sizeof(seam2), hash);
hash = MurmurHash2(&may_skip, sizeof(may_skip), hash); hash = upb_murmur_hash2(&may_skip, sizeof(may_skip), hash);
return hash; return hash;
} }

2
tests/pb/test_varint.c
Unescape View File

@ -101,7 +101,7 @@ static void test_varint_decoder(upb_decoderet (*decoder)(const char*)) {
upb_decoderet _upb_vdecode_ ## decoder(const char *p) { \ upb_decoderet _upb_vdecode_ ## decoder(const char *p) { \
return upb_vdecode_ ## decoder(p); \ return upb_vdecode_ ## decoder(p); \
} \ } \
void test_ ## decoder() { \ void test_ ## decoder(void) { \
test_varint_decoder(&_upb_vdecode_ ## decoder); \ test_varint_decoder(&_upb_vdecode_ ## decoder); \
} \ } \

18
upb/decode.c
Unescape View File

@ -74,7 +74,7 @@ static bool upb_decode_varint32(const char **ptr, const char *limit,
uint32_t *val) { uint32_t *val) {
uint64_t u64; uint64_t u64;
CHK(upb_decode_varint(ptr, limit, &u64) && u64 <= UINT32_MAX); CHK(upb_decode_varint(ptr, limit, &u64) && u64 <= UINT32_MAX);
*val = u64; *val = (uint32_t)u64;
return true; return true;
} }
@ -336,7 +336,7 @@ static bool upb_decode_varintfield(upb_decstate *d, upb_decframe *frame,
case UPB_DESCRIPTOR_TYPE_INT32: case UPB_DESCRIPTOR_TYPE_INT32:
case UPB_DESCRIPTOR_TYPE_UINT32: case UPB_DESCRIPTOR_TYPE_UINT32:
case UPB_DESCRIPTOR_TYPE_ENUM: { case UPB_DESCRIPTOR_TYPE_ENUM: {
uint32_t val32 = val; uint32_t val32 = (uint32_t)val;
CHK(upb_decode_addval(frame, field, &val32, sizeof(val32))); CHK(upb_decode_addval(frame, field, &val32, sizeof(val32)));
break; break;
} }
@ -346,7 +346,7 @@ static bool upb_decode_varintfield(upb_decstate *d, upb_decframe *frame,
break; break;
} }
case UPB_DESCRIPTOR_TYPE_SINT32: { case UPB_DESCRIPTOR_TYPE_SINT32: {
int32_t decoded = upb_zzdecode_32(val); int32_t decoded = upb_zzdecode_32((uint32_t)val);
CHK(upb_decode_addval(frame, field, &decoded, sizeof(decoded))); CHK(upb_decode_addval(frame, field, &decoded, sizeof(decoded)));
break; break;
} }
@ -425,7 +425,10 @@ static bool upb_decode_toarray(upb_decstate *d, upb_decframe *frame,
upb_array *arr = upb_getorcreatearr(frame, field); upb_array *arr = upb_getorcreatearr(frame, field);
CHK(arr); CHK(arr);
#define VARINT_CASE(ctype, decode) \ #define VARINT_CASE(ctype, decode) \
VARINT_CASE_EX(ctype, decode, decode)
#define VARINT_CASE_EX(ctype, decode, dtype) \
{ \ { \
const char *ptr = d->ptr; \ const char *ptr = d->ptr; \
const char *limit = ptr + len; \ const char *limit = ptr + len; \
@ -433,7 +436,7 @@ static bool upb_decode_toarray(upb_decstate *d, upb_decframe *frame,
uint64_t val; \ uint64_t val; \
ctype decoded; \ ctype decoded; \
CHK(upb_decode_varint(&ptr, limit, &val)); \ CHK(upb_decode_varint(&ptr, limit, &val)); \
decoded = (decode)(val); \ decoded = (decode)((dtype)val); \
CHK(upb_array_add(arr, 1, sizeof(decoded), &decoded, d->arena)); \ CHK(upb_array_add(arr, 1, sizeof(decoded), &decoded, d->arena)); \
} \ } \
d->ptr = ptr; \ d->ptr = ptr; \
@ -464,9 +467,9 @@ static bool upb_decode_toarray(upb_decstate *d, upb_decframe *frame,
case UPB_DESCRIPTOR_TYPE_BOOL: case UPB_DESCRIPTOR_TYPE_BOOL:
VARINT_CASE(bool, bool); VARINT_CASE(bool, bool);
case UPB_DESCRIPTOR_TYPE_SINT32: case UPB_DESCRIPTOR_TYPE_SINT32:
VARINT_CASE(int32_t, upb_zzdecode_32); VARINT_CASE_EX(int32_t, upb_zzdecode_32, uint32_t);
case UPB_DESCRIPTOR_TYPE_SINT64: case UPB_DESCRIPTOR_TYPE_SINT64:
VARINT_CASE(int64_t, upb_zzdecode_64); VARINT_CASE_EX(int64_t, upb_zzdecode_64, uint64_t);
case UPB_DESCRIPTOR_TYPE_MESSAGE: { case UPB_DESCRIPTOR_TYPE_MESSAGE: {
const upb_msglayout *subm; const upb_msglayout *subm;
upb_msg *submsg = upb_addmsg(frame, field, &subm); upb_msg *submsg = upb_addmsg(frame, field, &subm);
@ -570,6 +573,7 @@ static bool upb_decode_field(upb_decstate *d, upb_decframe *frame) {
CHK(upb_append_unknown(d, frame)); CHK(upb_append_unknown(d, frame));
return true; return true;
} }
UPB_UNREACHABLE();
} }
static bool upb_decode_message(upb_decstate *d, char *msg, const upb_msglayout *l) { static bool upb_decode_message(upb_decstate *d, char *msg, const upb_msglayout *l) {

3
upb/def.c
Unescape View File

@ -1029,6 +1029,7 @@ static bool parse_default(const symtab_addctx *ctx, const char *str, size_t len,
} else { } else {
return false; return false;
} }
break;
} }
case UPB_TYPE_STRING: case UPB_TYPE_STRING:
f->defaultval.str = newstr(ctx->alloc, str, len); f->defaultval.str = newstr(ctx->alloc, str, len);
@ -1633,7 +1634,7 @@ void upb_symtab_free(upb_symtab *s) {
upb_gfree(s); upb_gfree(s);
} }
upb_symtab *upb_symtab_new() { upb_symtab *upb_symtab_new(void) {
upb_symtab *s = upb_gmalloc(sizeof(*s)); upb_symtab *s = upb_gmalloc(sizeof(*s));
upb_alloc *alloc; upb_alloc *alloc;

2
upb/def.h
Unescape View File

@ -837,7 +837,7 @@ class upb::FileDefPtr {
extern "C" { extern "C" {
#endif #endif
upb_symtab *upb_symtab_new(); upb_symtab *upb_symtab_new(void);
void upb_symtab_free(upb_symtab* s); void upb_symtab_free(upb_symtab* s);
const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym); const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym);
const upb_msgdef *upb_symtab_lookupmsg2( const upb_msgdef *upb_symtab_lookupmsg2(

8
upb/encode.c
Unescape View File

@ -25,8 +25,8 @@ static size_t upb_encode_varint(uint64_t val, char *buf) {
return i; return i;
} }
static uint32_t upb_zzencode_32(int32_t n) { return (n << 1) ^ (n >> 31); } static uint32_t upb_zzencode_32(int32_t n) { return ((uint32_t)n << 1) ^ (n >> 31); }
static uint64_t upb_zzencode_64(int64_t n) { return (n << 1) ^ (n >> 63); } static uint64_t upb_zzencode_64(int64_t n) { return ((uint64_t)n << 1) ^ (n >> 63); }
typedef struct { typedef struct {
upb_alloc *alloc; upb_alloc *alloc;
@ -48,7 +48,9 @@ static bool upb_encode_growbuffer(upb_encstate *e, size_t bytes) {
CHK(new_buf); CHK(new_buf);
/* We want previous data at the end, realloc() put it at the beginning. */ /* We want previous data at the end, realloc() put it at the beginning. */
memmove(new_buf + new_size - old_size, e->buf, old_size); if (old_size > 0) {
memmove(new_buf + new_size - old_size, e->buf, old_size);
}
e->ptr = new_buf + new_size - (e->limit - e->ptr); e->ptr = new_buf + new_size - (e->limit - e->ptr);
e->limit = new_buf + new_size; e->limit = new_buf + new_size;

4
upb/generated_util.h
Unescape View File

@ -87,11 +87,11 @@ UPB_INLINE bool _upb_has_field(const void *msg, size_t idx) {
} }
UPB_INLINE bool _upb_sethas(const void *msg, size_t idx) { UPB_INLINE bool _upb_sethas(const void *msg, size_t idx) {
return (*PTR_AT(msg, idx / 8, char)) |= (1 << (idx % 8)); return (*PTR_AT(msg, idx / 8, char)) |= (char)(1 << (idx % 8));
} }
UPB_INLINE bool _upb_clearhas(const void *msg, size_t idx) { UPB_INLINE bool _upb_clearhas(const void *msg, size_t idx) {
return (*PTR_AT(msg, idx / 8, char)) &= ~(1 << (idx % 8)); return (*PTR_AT(msg, idx / 8, char)) &= (char)(~(1 << (idx % 8)));
} }
UPB_INLINE bool _upb_has_oneof_field(const void *msg, size_t case_ofs, int32_t num) { UPB_INLINE bool _upb_has_oneof_field(const void *msg, size_t case_ofs, int32_t num) {

2
upb/json/parser.h
Unescape View File

@ -113,7 +113,7 @@ typedef struct upb_json_codecache upb_json_codecache;
extern "C" { extern "C" {
#endif #endif
upb_json_codecache *upb_json_codecache_new(); upb_json_codecache *upb_json_codecache_new(void);
void upb_json_codecache_free(upb_json_codecache *cache); void upb_json_codecache_free(upb_json_codecache *cache);
const upb_json_parsermethod* upb_json_codecache_get(upb_json_codecache* cache, const upb_json_parsermethod* upb_json_codecache_get(upb_json_codecache* cache,
const upb_msgdef* md); const upb_msgdef* md);

13
upb/json/parser.rl
Unescape View File

@ -947,7 +947,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
upb_fieldtype_t type = upb_fielddef_type(p->top->f); upb_fieldtype_t type = upb_fielddef_type(p->top->f);
double val; double val;
double dummy; double dummy;
double inf = 1.0 / 0.0; /* C89 does not have an INFINITY macro. */ double inf = UPB_INFINITY;
errno = 0; errno = 0;
@ -1189,7 +1189,8 @@ static bool start_any_stringval(upb_json_parser *p) {
static bool start_stringval(upb_json_parser *p) { static bool start_stringval(upb_json_parser *p) {
if (is_top_level(p)) { if (is_top_level(p)) {
if (is_string_wrapper_object(p)) { if (is_string_wrapper_object(p) ||
is_number_wrapper_object(p)) {
start_wrapper_object(p); start_wrapper_object(p);
} else if (is_wellknown_msg(p, UPB_WELLKNOWN_FIELDMASK)) { } else if (is_wellknown_msg(p, UPB_WELLKNOWN_FIELDMASK)) {
start_fieldmask_object(p); start_fieldmask_object(p);
@ -1202,7 +1203,8 @@ static bool start_stringval(upb_json_parser *p) {
} else { } else {
return false; return false;
} }
} else if (does_string_wrapper_start(p)) { } else if (does_string_wrapper_start(p) ||
does_number_wrapper_start(p)) {
if (!start_subobject(p)) { if (!start_subobject(p)) {
return false; return false;
} }
@ -1408,7 +1410,8 @@ static bool end_stringval(upb_json_parser *p) {
return false; return false;
} }
if (does_string_wrapper_end(p)) { if (does_string_wrapper_end(p) ||
does_number_wrapper_end(p)) {
end_wrapper_object(p); end_wrapper_object(p);
if (!is_top_level(p)) { if (!is_top_level(p)) {
end_subobject(p); end_subobject(p);
@ -2958,7 +2961,7 @@ const upb_byteshandler *upb_json_parsermethod_inputhandler(
return &m->input_handler_; return &m->input_handler_;
} }
upb_json_codecache *upb_json_codecache_new() { upb_json_codecache *upb_json_codecache_new(void) {
upb_alloc *alloc; upb_alloc *alloc;
upb_json_codecache *c; upb_json_codecache *c;

45
upb/json/printer.c
Unescape View File

@ -181,11 +181,11 @@ const char neginf[] = "\"-Infinity\"";
const char inf[] = "\"Infinity\""; const char inf[] = "\"Infinity\"";
static size_t fmt_double(double val, char* buf, size_t length) { static size_t fmt_double(double val, char* buf, size_t length) {
if (val == (1.0 / 0.0)) { if (val == UPB_INFINITY) {
CHKLENGTH(length >= strlen(inf)); CHKLENGTH(length >= strlen(inf));
strcpy(buf, inf); strcpy(buf, inf);
return strlen(inf); return strlen(inf);
} else if (val == (-1.0 / 0.0)) { } else if (val == -UPB_INFINITY) {
CHKLENGTH(length >= strlen(neginf)); CHKLENGTH(length >= strlen(neginf));
strcpy(buf, neginf); strcpy(buf, neginf);
return strlen(neginf); return strlen(neginf);
@ -208,18 +208,32 @@ static size_t fmt_bool(bool val, char* buf, size_t length) {
return n; return n;
} }
static size_t fmt_int64(long val, char* buf, size_t length) { static size_t fmt_int64_as_number(long long val, char* buf, size_t length) {
size_t n = _upb_snprintf(buf, length, "%ld", val); size_t n = _upb_snprintf(buf, length, "%lld", val);
CHKLENGTH(n > 0 && n < length); CHKLENGTH(n > 0 && n < length);
return n; return n;
} }
static size_t fmt_uint64(unsigned long long val, char* buf, size_t length) { static size_t fmt_uint64_as_number(
unsigned long long val, char* buf, size_t length) {
size_t n = _upb_snprintf(buf, length, "%llu", val); size_t n = _upb_snprintf(buf, length, "%llu", val);
CHKLENGTH(n > 0 && n < length); CHKLENGTH(n > 0 && n < length);
return n; return n;
} }
static size_t fmt_int64_as_string(long long val, char* buf, size_t length) {
size_t n = _upb_snprintf(buf, length, "\"%lld\"", val);
CHKLENGTH(n > 0 && n < length);
return n;
}
static size_t fmt_uint64_as_string(
unsigned long long val, char* buf, size_t length) {
size_t n = _upb_snprintf(buf, length, "\"%llu\"", val);
CHKLENGTH(n > 0 && n < length);
return n;
}
/* Print a map key given a field name. Called by scalar field handlers and by /* Print a map key given a field name. Called by scalar field handlers and by
* startseq for repeated fields. */ * startseq for repeated fields. */
static bool putkey(void *closure, const void *handler_data) { static bool putkey(void *closure, const void *handler_data) {
@ -263,8 +277,11 @@ static bool putkey(void *closure, const void *handler_data) {
static bool putmapkey_##type(void *closure, const void *handler_data, \ static bool putmapkey_##type(void *closure, const void *handler_data, \
type val) { \ type val) { \
upb_json_printer *p = closure; \ upb_json_printer *p = closure; \
char data[64]; \
size_t length = fmt_func(val, data, sizeof(data)); \
UPB_UNUSED(handler_data); \
print_data(p, "\"", 1); \ print_data(p, "\"", 1); \
CHK(put##type(closure, handler_data, val)); \ print_data(p, data, length); \
print_data(p, "\":", 2); \ print_data(p, "\":", 2); \
return true; \ return true; \
} }
@ -272,17 +289,17 @@ static bool putkey(void *closure, const void *handler_data) {
TYPE_HANDLERS(double, fmt_double) TYPE_HANDLERS(double, fmt_double)
TYPE_HANDLERS(float, fmt_float) TYPE_HANDLERS(float, fmt_float)
TYPE_HANDLERS(bool, fmt_bool) TYPE_HANDLERS(bool, fmt_bool)
TYPE_HANDLERS(int32_t, fmt_int64) TYPE_HANDLERS(int32_t, fmt_int64_as_number)
TYPE_HANDLERS(uint32_t, fmt_int64) TYPE_HANDLERS(uint32_t, fmt_int64_as_number)
TYPE_HANDLERS(int64_t, fmt_int64) TYPE_HANDLERS(int64_t, fmt_int64_as_string)
TYPE_HANDLERS(uint64_t, fmt_uint64) TYPE_HANDLERS(uint64_t, fmt_uint64_as_string)
/* double and float are not allowed to be map keys. */ /* double and float are not allowed to be map keys. */
TYPE_HANDLERS_MAPKEY(bool, fmt_bool) TYPE_HANDLERS_MAPKEY(bool, fmt_bool)
TYPE_HANDLERS_MAPKEY(int32_t, fmt_int64) TYPE_HANDLERS_MAPKEY(int32_t, fmt_int64_as_number)
TYPE_HANDLERS_MAPKEY(uint32_t, fmt_int64) TYPE_HANDLERS_MAPKEY(uint32_t, fmt_int64_as_number)
TYPE_HANDLERS_MAPKEY(int64_t, fmt_int64) TYPE_HANDLERS_MAPKEY(int64_t, fmt_int64_as_number)
TYPE_HANDLERS_MAPKEY(uint64_t, fmt_uint64) TYPE_HANDLERS_MAPKEY(uint64_t, fmt_uint64_as_number)
#undef TYPE_HANDLERS #undef TYPE_HANDLERS
#undef TYPE_HANDLERS_MAPKEY #undef TYPE_HANDLERS_MAPKEY

2
upb/legacy_msg_reflection.c
Unescape View File

@ -292,7 +292,7 @@ struct upb_mapiter {
upb_fieldtype_t key_type; upb_fieldtype_t key_type;
}; };
size_t upb_mapiter_sizeof() { size_t upb_mapiter_sizeof(void) {
return sizeof(upb_mapiter); return sizeof(upb_mapiter);
} }

2
upb/legacy_msg_reflection.h
Unescape View File

@ -171,7 +171,7 @@ bool upb_map_del(upb_map *map, upb_fieldtype_t key_type, upb_msgval key,
* and if you keep invalidating the iterator during iteration, the program may * and if you keep invalidating the iterator during iteration, the program may
* enter an infinite loop. */ * enter an infinite loop. */
size_t upb_mapiter_sizeof(); size_t upb_mapiter_sizeof(void);
void upb_mapiter_begin(upb_mapiter *i, upb_fieldtype_t key_type, void upb_mapiter_begin(upb_mapiter *i, upb_fieldtype_t key_type,
const upb_map *t); const upb_map *t);

2
upb/msg.c
Unescape View File

@ -5,7 +5,7 @@
#include "upb/port_def.inc" #include "upb/port_def.inc"
#define VOIDPTR_AT(msg, ofs) (void*)((char*)msg + ofs) #define VOIDPTR_AT(msg, ofs) (void*)((char*)msg + (int)ofs)
/* Internal members of a upb_msg. We can change this without breaking binary /* Internal members of a upb_msg. We can change this without breaking binary
* compatibility. We put these before the user's data. The user's upb_msg* * compatibility. We put these before the user's data. The user's upb_msg*

40
upb/pb/compile_decoder.c
Unescape View File

@ -69,7 +69,7 @@ static void freegroup(mgroup *g) {
upb_gfree(g); upb_gfree(g);
} }
mgroup *newgroup() { mgroup *newgroup(void) {
mgroup *g = upb_gmalloc(sizeof(*g)); mgroup *g = upb_gmalloc(sizeof(*g));
upb_inttable_init(&g->methods, UPB_CTYPE_PTR); upb_inttable_init(&g->methods, UPB_CTYPE_PTR);
g->bytecode = NULL; g->bytecode = NULL;
@ -149,7 +149,7 @@ static int32_t getofs(uint32_t instruction) {
static void setofs(uint32_t *instruction, int32_t ofs) { static void setofs(uint32_t *instruction, int32_t ofs) {
if (op_has_longofs(*instruction)) { if (op_has_longofs(*instruction)) {
*instruction = getop(*instruction) | ofs << 8; *instruction = getop(*instruction) | (uint32_t)ofs << 8;
} else { } else {
*instruction = (*instruction & ~0xff00) | ((ofs & 0xff) << 8); *instruction = (*instruction & ~0xff00) | ((ofs & 0xff) << 8);
} }
@ -822,12 +822,10 @@ static void set_bytecode_handlers(mgroup *g) {
/* TODO(haberman): allow this to be constructed for an arbitrary set of dest /* TODO(haberman): allow this to be constructed for an arbitrary set of dest
* handlers and other mgroups (but verify we have a transitive closure). */ * handlers and other mgroups (but verify we have a transitive closure). */
const mgroup *mgroup_new(const upb_handlers *dest, bool allowjit, bool lazy) { const mgroup *mgroup_new(const upb_handlers *dest, bool lazy) {
mgroup *g; mgroup *g;
compiler *c; compiler *c;
UPB_UNUSED(allowjit);
g = newgroup(); g = newgroup();
c = newcompiler(g, lazy); c = newcompiler(g, lazy);
find_methods(c, dest); find_methods(c, dest);
@ -872,7 +870,6 @@ upb_pbcodecache *upb_pbcodecache_new(upb_handlercache *dest) {
if (!c) return NULL; if (!c) return NULL;
c->dest = dest; c->dest = dest;
c->allow_jit = true;
c->lazy = false; c->lazy = false;
c->arena = upb_arena_new(); c->arena = upb_arena_new();
@ -882,13 +879,12 @@ upb_pbcodecache *upb_pbcodecache_new(upb_handlercache *dest) {
} }
void upb_pbcodecache_free(upb_pbcodecache *c) { void upb_pbcodecache_free(upb_pbcodecache *c) {
size_t i; upb_inttable_iter i;
for (i = 0; i < upb_inttable_count(&c->groups); i++) { upb_inttable_begin(&i, &c->groups);
upb_value v; for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
bool ok = upb_inttable_lookup(&c->groups, i, &v); upb_value val = upb_inttable_iter_value(&i);
UPB_ASSERT(ok); freegroup((void*)upb_value_getconstptr(val));
freegroup((void*)upb_value_getconstptr(v));
} }
upb_inttable_uninit(&c->groups); upb_inttable_uninit(&c->groups);
@ -896,15 +892,6 @@ void upb_pbcodecache_free(upb_pbcodecache *c) {
upb_gfree(c); upb_gfree(c);
} }
bool upb_pbcodecache_allowjit(const upb_pbcodecache *c) {
return c->allow_jit;
}
void upb_pbcodecache_setallowjit(upb_pbcodecache *c, bool allow) {
UPB_ASSERT(upb_inttable_count(&c->groups) == 0);
c->allow_jit = allow;
}
void upb_pbdecodermethodopts_setlazy(upb_pbcodecache *c, bool lazy) { void upb_pbdecodermethodopts_setlazy(upb_pbcodecache *c, bool lazy) {
UPB_ASSERT(upb_inttable_count(&c->groups) == 0); UPB_ASSERT(upb_inttable_count(&c->groups) == 0);
c->lazy = lazy; c->lazy = lazy;
@ -917,11 +904,14 @@ const upb_pbdecodermethod *upb_pbcodecache_get(upb_pbcodecache *c,
const upb_handlers *h; const upb_handlers *h;
const mgroup *g; const mgroup *g;
/* Right now we build a new DecoderMethod every time.
* TODO(haberman): properly cache methods by their true key. */
h = upb_handlercache_get(c->dest, md); h = upb_handlercache_get(c->dest, md);
g = mgroup_new(h, c->allow_jit, c->lazy); if (upb_inttable_lookupptr(&c->groups, md, &v)) {
upb_inttable_push(&c->groups, upb_value_constptr(g)); g = upb_value_getconstptr(v);
} else {
g = mgroup_new(h, c->lazy);
ok = upb_inttable_insertptr(&c->groups, md, upb_value_constptr(g));
UPB_ASSERT(ok);
}
ok = upb_inttable_lookupptr(&g->methods, h, &v); ok = upb_inttable_lookupptr(&g->methods, h, &v);
UPB_ASSERT(ok); UPB_ASSERT(ok);

29
upb/pb/decoder.c
Unescape View File

@ -77,16 +77,6 @@ static size_t stacksize(upb_pbdecoder *d, size_t entries) {
static size_t callstacksize(upb_pbdecoder *d, size_t entries) { static size_t callstacksize(upb_pbdecoder *d, size_t entries) {
UPB_UNUSED(d); UPB_UNUSED(d);
#ifdef UPB_USE_JIT_X64
if (d->method_->is_native_) {
/* Each native stack frame needs two pointers, plus we need a few frames for
* the enter/exit trampolines. */
size_t ret = entries * sizeof(void*) * 2;
ret += sizeof(void*) * 10;
return ret;
}
#endif
return entries * sizeof(uint32_t*); return entries * sizeof(uint32_t*);
} }
@ -902,17 +892,6 @@ void *upb_pbdecoder_startbc(void *closure, const void *pc, size_t size_hint) {
return d; return d;
} }
void *upb_pbdecoder_startjit(void *closure, const void *hd, size_t size_hint) {
upb_pbdecoder *d = closure;
UPB_UNUSED(hd);
UPB_UNUSED(size_hint);
d->top->end_ofs = UINT64_MAX;
d->bufstart_ofs = 0;
d->call_len = 0;
d->skip = 0;
return d;
}
bool upb_pbdecoder_end(void *closure, const void *handler_data) { bool upb_pbdecoder_end(void *closure, const void *handler_data) {
upb_pbdecoder *d = closure; upb_pbdecoder *d = closure;
const upb_pbdecodermethod *method = handler_data; const upb_pbdecodermethod *method = handler_data;
@ -938,14 +917,6 @@ bool upb_pbdecoder_end(void *closure, const void *handler_data) {
end = offset(d); end = offset(d);
d->top->end_ofs = end; d->top->end_ofs = end;
#ifdef UPB_USE_JIT_X64
if (method->is_native_) {
const mgroup *group = (const mgroup*)method->group;
if (d->top != d->stack)
d->stack->end_ofs = 0;
group->jit_code(closure, method->code_base.ptr, &dummy, 0, NULL);
} else
#endif
{ {
const uint32_t *p = d->pc; const uint32_t *p = d->pc;
d->stack->end_ofs = end; d->stack->end_ofs = end;

24
upb/pb/decoder.int.h
Unescape View File

@ -80,7 +80,7 @@ struct upb_pbcodecache {
bool allow_jit; bool allow_jit;
bool lazy; bool lazy;
/* Array of mgroups. */ /* Map of upb_msgdef -> mgroup. */
upb_inttable groups; upb_inttable groups;
}; };
@ -96,15 +96,6 @@ typedef struct {
/* The bytecode for our methods, if any exists. Owned by us. */ /* The bytecode for our methods, if any exists. Owned by us. */
uint32_t *bytecode; uint32_t *bytecode;
uint32_t *bytecode_end; uint32_t *bytecode_end;
#ifdef UPB_USE_JIT_X64
/* JIT-generated machine code, if any. */
upb_string_handlerfunc *jit_code;
/* The size of the jit_code (required to munmap()). */
size_t jit_size;
char *debug_info;
void *dl;
#endif
} mgroup; } mgroup;
/* The maximum that any submessages can be nested. Matches proto2's limit. /* The maximum that any submessages can be nested. Matches proto2's limit.
@ -215,19 +206,10 @@ struct upb_pbdecoder {
size_t stack_size; size_t stack_size;
upb_status *status; upb_status *status;
#ifdef UPB_USE_JIT_X64
/* Used momentarily by the generated code to store a value while a user
* function is called. */
uint32_t tmp_len;
const void *saved_rsp;
#endif
}; };
/* Decoder entry points; used as handlers. */ /* Decoder entry points; used as handlers. */
void *upb_pbdecoder_startbc(void *closure, const void *pc, size_t size_hint); void *upb_pbdecoder_startbc(void *closure, const void *pc, size_t size_hint);
void *upb_pbdecoder_startjit(void *closure, const void *hd, size_t size_hint);
size_t upb_pbdecoder_decode(void *closure, const void *hd, const char *buf, size_t upb_pbdecoder_decode(void *closure, const void *hd, const char *buf,
size_t size, const upb_bufhandle *handle); size_t size, const upb_bufhandle *handle);
bool upb_pbdecoder_end(void *closure, const void *handler_data); bool upb_pbdecoder_end(void *closure, const void *handler_data);
@ -251,10 +233,6 @@ extern const char *kPbDecoderSubmessageTooLong;
/* Access to decoderplan members needed by the decoder. */ /* Access to decoderplan members needed by the decoder. */
const char *upb_pbdecoder_getopname(unsigned int op); const char *upb_pbdecoder_getopname(unsigned int op);
/* JIT codegen entry point. */
void upb_pbdecoder_jit(mgroup *group);
void upb_pbdecoder_freejit(mgroup *group);
/* A special label that means "do field dispatch for this message and branch to /* A special label that means "do field dispatch for this message and branch to
* wherever that takes you." */ * wherever that takes you." */
#define LABEL_DISPATCH 0 #define LABEL_DISPATCH 0

2
upb/pb/encoder.c
Unescape View File

@ -524,7 +524,7 @@ void upb_pb_encoder_reset(upb_pb_encoder *e) {
/* public API *****************************************************************/ /* public API *****************************************************************/
upb_handlercache *upb_pb_encoder_newcache() { upb_handlercache *upb_pb_encoder_newcache(void) {
return upb_handlercache_new(newhandlers_callback, NULL); return upb_handlercache_new(newhandlers_callback, NULL);
} }

2
upb/pb/encoder.h
Unescape View File

@ -45,7 +45,7 @@ upb_pb_encoder* upb_pb_encoder_create(upb_arena* a, const upb_handlers* h,
/* Lazily builds and caches handlers that will push encoded data to a bytessink. /* Lazily builds and caches handlers that will push encoded data to a bytessink.
* Any msgdef objects used with this object must outlive it. */ * Any msgdef objects used with this object must outlive it. */
upb_handlercache *upb_pb_encoder_newcache(); upb_handlercache *upb_pb_encoder_newcache(void);
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" { */ } /* extern "C" { */

2
upb/pb/textprinter.c
Unescape View File

@ -329,7 +329,7 @@ upb_textprinter *upb_textprinter_create(upb_arena *arena, const upb_handlers *h,
return p; return p;
} }
upb_handlercache *upb_textprinter_newcache() { upb_handlercache *upb_textprinter_newcache(void) {
return upb_handlercache_new(&onmreg, NULL); return upb_handlercache_new(&onmreg, NULL);
} }

2
upb/pb/textprinter.h
Unescape View File

@ -31,7 +31,7 @@ upb_textprinter *upb_textprinter_create(upb_arena *arena, const upb_handlers *h,
upb_bytessink output); upb_bytessink output);
void upb_textprinter_setsingleline(upb_textprinter *p, bool single_line); void upb_textprinter_setsingleline(upb_textprinter *p, bool single_line);
upb_sink upb_textprinter_input(upb_textprinter *p); upb_sink upb_textprinter_input(upb_textprinter *p);
upb_handlercache *upb_textprinter_newcache(); upb_handlercache *upb_textprinter_newcache(void);
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */

8
upb/pb/varint.int.h
Unescape View File

@ -46,8 +46,12 @@ UPB_INLINE int32_t upb_zzdec_32(uint32_t n) {
UPB_INLINE int64_t upb_zzdec_64(uint64_t n) { UPB_INLINE int64_t upb_zzdec_64(uint64_t n) {
return (n >> 1) ^ -(int64_t)(n & 1); return (n >> 1) ^ -(int64_t)(n & 1);
} }
UPB_INLINE uint32_t upb_zzenc_32(int32_t n) { return (n << 1) ^ (n >> 31); } UPB_INLINE uint32_t upb_zzenc_32(int32_t n) {
UPB_INLINE uint64_t upb_zzenc_64(int64_t n) { return (n << 1) ^ (n >> 63); } return ((uint32_t)n << 1) ^ (n >> 31);
}
UPB_INLINE uint64_t upb_zzenc_64(int64_t n) {
return ((uint64_t)n << 1) ^ (n >> 63);
}
/* Decoding *******************************************************************/ /* Decoding *******************************************************************/

27
upb/port.c
Unescape View File

@ -0,0 +1,27 @@
#include "upb/upb.h"
#include "upb/port_def.inc"
#ifdef UPB_MSVC_VSNPRINTF
/* Visual C++ earlier than 2015 doesn't have standard C99 snprintf and
* vsnprintf. To support them, missing functions are manually implemented
* using the existing secure functions. */
int msvc_vsnprintf(char* s, size_t n, const char* format, va_list arg) {
if (!s) {
return _vscprintf(format, arg);
}
int ret = _vsnprintf_s(s, n, _TRUNCATE, format, arg);
if (ret < 0) {
ret = _vscprintf(format, arg);
}
return ret;
}
int msvc_snprintf(char* s, size_t n, const char* format, ...) {
va_list arg;
va_start(arg, format);
int ret = msvc_vsnprintf(s, n, format, arg);
va_end(arg);
return ret;
}
#endif

35
upb/port_def.inc
Unescape View File

@ -45,14 +45,20 @@
/* UPB_INLINE: inline if possible, emit standalone code if required. */ /* UPB_INLINE: inline if possible, emit standalone code if required. */
#ifdef __cplusplus #ifdef __cplusplus
#define UPB_INLINE inline #define UPB_INLINE inline
#elif defined (__GNUC__) #elif defined (__GNUC__) || defined(__clang__)
#define UPB_INLINE static __inline__ #define UPB_INLINE static __inline__
#else #else
#define UPB_INLINE static #define UPB_INLINE static
#endif #endif
/* Hints to the compiler about likely/unlikely branches. */ /* Hints to the compiler about likely/unlikely branches. */
#if defined (__GNUC__) || defined(__clang__)
#define UPB_LIKELY(x) __builtin_expect((x),1) #define UPB_LIKELY(x) __builtin_expect((x),1)
#define UPB_UNLIKELY(x) __builtin_expect((x),0)
#else
#define UPB_LIKELY(x) (x)
#define UPB_UNLIKELY(x) (x)
#endif
/* Define UPB_BIG_ENDIAN manually if you're on big endian and your compiler /* Define UPB_BIG_ENDIAN manually if you're on big endian and your compiler
* doesn't provide these preprocessor symbols. */ * doesn't provide these preprocessor symbols. */
@ -77,6 +83,21 @@
#define _upb_snprintf snprintf #define _upb_snprintf snprintf
#define _upb_vsnprintf vsnprintf #define _upb_vsnprintf vsnprintf
#define _upb_va_copy(a, b) va_copy(a, b) #define _upb_va_copy(a, b) va_copy(a, b)
#elif defined(_MSC_VER)
/* Microsoft C/C++ versions. */
#include <stdarg.h>
#include <stdio.h>
#if _MSC_VER < 1900
int msvc_snprintf(char* s, size_t n, const char* format, ...);
int msvc_vsnprintf(char* s, size_t n, const char* format, va_list arg);
#define UPB_MSVC_VSNPRINTF
#define _upb_snprintf msvc_snprintf
#define _upb_vsnprintf msvc_vsnprintf
#else
#define _upb_snprintf snprintf
#define _upb_vsnprintf vsnprintf
#endif
#define _upb_va_copy(a, b) va_copy(a, b)
#elif defined __GNUC__ #elif defined __GNUC__
/* A few hacky workarounds for functions not in C89. /* A few hacky workarounds for functions not in C89.
* For internal use only! * For internal use only!
@ -93,7 +114,7 @@
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) || \ #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) || \
(defined(_MSC_VER) && _MSC_VER >= 1900) (defined(_MSC_VER) && _MSC_VER >= 1900)
// C++11 is present /* C++11 is present */
#else #else
#error upb requires C++11 for C++ support #error upb requires C++11 for C++ support
#endif #endif
@ -116,8 +137,16 @@
* exist in debug mode. This turns into regular assert. */ * exist in debug mode. This turns into regular assert. */
#define UPB_ASSERT_DEBUGVAR(expr) assert(expr) #define UPB_ASSERT_DEBUGVAR(expr) assert(expr)
#ifdef __GNUC__ #if defined(__GNUC__) || defined(__clang__)
#define UPB_UNREACHABLE() do { assert(0); __builtin_unreachable(); } while(0) #define UPB_UNREACHABLE() do { assert(0); __builtin_unreachable(); } while(0)
#else #else
#define UPB_UNREACHABLE() do { assert(0); } while(0) #define UPB_UNREACHABLE() do { assert(0); } while(0)
#endif #endif
/* UPB_INFINITY representing floating-point positive infinity. */
#include <math.h>
#ifdef INFINITY
#define UPB_INFINITY INFINITY
#else
#define UPB_INFINITY (1.0 / 0.0)
#endif

2
upb/port_undef.inc
Unescape View File

@ -14,6 +14,8 @@
#undef UPB_ASSERT #undef UPB_ASSERT
#undef UPB_ASSERT_DEBUGVAR #undef UPB_ASSERT_DEBUGVAR
#undef UPB_UNREACHABLE #undef UPB_UNREACHABLE
#undef UPB_INFINITY
#undef UPB_MSVC_VSNPRINTF
#undef _upb_snprintf #undef _upb_snprintf
#undef _upb_vsnprintf #undef _upb_vsnprintf
#undef _upb_va_copy #undef _upb_va_copy

19
upb/table.c
Unescape View File

@ -276,14 +276,15 @@ static upb_tabkey strcopy(lookupkey_t k2, upb_alloc *a) {
char *str = upb_malloc(a, k2.str.len + sizeof(uint32_t) + 1); char *str = upb_malloc(a, k2.str.len + sizeof(uint32_t) + 1);
if (str == NULL) return 0; if (str == NULL) return 0;
memcpy(str, &len, sizeof(uint32_t)); memcpy(str, &len, sizeof(uint32_t));
memcpy(str + sizeof(uint32_t), k2.str.str, k2.str.len + 1); memcpy(str + sizeof(uint32_t), k2.str.str, k2.str.len);
str[sizeof(uint32_t) + k2.str.len] = '\0';
return (uintptr_t)str; return (uintptr_t)str;
} }
static uint32_t strhash(upb_tabkey key) { static uint32_t strhash(upb_tabkey key) {
uint32_t len; uint32_t len;
char *str = upb_tabstr(key, &len); char *str = upb_tabstr(key, &len);
return MurmurHash2(str, len, 0); return upb_murmur_hash2(str, len, 0);
} }
static bool streql(upb_tabkey k1, lookupkey_t k2) { static bool streql(upb_tabkey k1, lookupkey_t k2) {
@ -344,20 +345,20 @@ bool upb_strtable_insert3(upb_strtable *t, const char *k, size_t len,
tabkey = strcopy(key, a); tabkey = strcopy(key, a);
if (tabkey == 0) return false; if (tabkey == 0) return false;
hash = MurmurHash2(key.str.str, key.str.len, 0); hash = upb_murmur_hash2(key.str.str, key.str.len, 0);
insert(&t->t, key, tabkey, v, hash, &strhash, &streql); insert(&t->t, key, tabkey, v, hash, &strhash, &streql);
return true; return true;
} }
bool upb_strtable_lookup2(const upb_strtable *t, const char *key, size_t len, bool upb_strtable_lookup2(const upb_strtable *t, const char *key, size_t len,
upb_value *v) { upb_value *v) {
uint32_t hash = MurmurHash2(key, len, 0); uint32_t hash = upb_murmur_hash2(key, len, 0);
return lookup(&t->t, strkey2(key, len), v, hash, &streql); return lookup(&t->t, strkey2(key, len), v, hash, &streql);
} }
bool upb_strtable_remove3(upb_strtable *t, const char *key, size_t len, bool upb_strtable_remove3(upb_strtable *t, const char *key, size_t len,
upb_value *val, upb_alloc *alloc) { upb_value *val, upb_alloc *alloc) {
uint32_t hash = MurmurHash2(key, len, 0); uint32_t hash = upb_murmur_hash2(key, len, 0);
upb_tabkey tabkey; upb_tabkey tabkey;
if (rm(&t->t, strkey2(key, len), val, &tabkey, hash, &streql)) { if (rm(&t->t, strkey2(key, len), val, &tabkey, hash, &streql)) {
upb_free(alloc, (void*)tabkey); upb_free(alloc, (void*)tabkey);
@ -646,7 +647,7 @@ void upb_inttable_compact2(upb_inttable *t, upb_alloc *a) {
size_t arr_size = max[size_lg2] + 1; /* +1 so arr[max] will fit. */ size_t arr_size = max[size_lg2] + 1; /* +1 so arr[max] will fit. */
size_t hash_count = upb_inttable_count(t) - arr_count; size_t hash_count = upb_inttable_count(t) - arr_count;
size_t hash_size = hash_count ? (hash_count / MAX_LOAD) + 1 : 0; size_t hash_size = hash_count ? (hash_count / MAX_LOAD) + 1 : 0;
size_t hashsize_lg2 = log2ceil(hash_size); int hashsize_lg2 = log2ceil(hash_size);
upb_inttable_sizedinit(&new_t, t->t.ctype, arr_size, hashsize_lg2, a); upb_inttable_sizedinit(&new_t, t->t.ctype, arr_size, hashsize_lg2, a);
upb_inttable_begin(&i, t); upb_inttable_begin(&i, t);
@ -743,7 +744,7 @@ bool upb_inttable_iter_isequal(const upb_inttable_iter *i1,
* 1. It will not work incrementally. * 1. It will not work incrementally.
* 2. It will not produce the same results on little-endian and big-endian * 2. It will not produce the same results on little-endian and big-endian
* machines. */ * machines. */
uint32_t MurmurHash2(const void *key, size_t len, uint32_t seed) { uint32_t upb_murmur_hash2(const void *key, size_t len, uint32_t seed) {
/* 'm' and 'r' are mixing constants generated offline. /* 'm' and 'r' are mixing constants generated offline.
* They're not really 'magic', they just happen to work well. */ * They're not really 'magic', they just happen to work well. */
const uint32_t m = 0x5bd1e995; const uint32_t m = 0x5bd1e995;
@ -794,11 +795,11 @@ uint32_t MurmurHash2(const void *key, size_t len, uint32_t seed) {
#define MIX(h,k,m) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; } #define MIX(h,k,m) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; }
uint32_t MurmurHash2(const void * key, size_t len, uint32_t seed) { uint32_t upb_murmur_hash2(const void * key, size_t len, uint32_t seed) {
const uint32_t m = 0x5bd1e995; const uint32_t m = 0x5bd1e995;
const int32_t r = 24; const int32_t r = 24;
const uint8_t * data = (const uint8_t *)key; const uint8_t * data = (const uint8_t *)key;
uint32_t h = seed ^ len; uint32_t h = (uint32_t)(seed ^ len);
uint8_t align = (uintptr_t)data & 3; uint8_t align = (uintptr_t)data & 3;
if(align && (len >= 4)) { if(align && (len >= 4)) {

2
upb/table.int.h
Unescape View File

@ -245,7 +245,7 @@ UPB_INLINE bool upb_tabent_isempty(const upb_tabent *e) {
} }
/* Used by some of the unit tests for generic hashing functionality. */ /* Used by some of the unit tests for generic hashing functionality. */
uint32_t MurmurHash2(const void * key, size_t len, uint32_t seed); uint32_t upb_murmur_hash2(const void * key, size_t len, uint32_t seed);
UPB_INLINE uintptr_t upb_intkey(uintptr_t key) { UPB_INLINE uintptr_t upb_intkey(uintptr_t key) {
return key; return key;

12
upb/upb.h
Unescape View File

@ -159,8 +159,16 @@ UPB_INLINE void upb_free(upb_alloc *alloc, void *ptr) {
/* The global allocator used by upb. Uses the standard malloc()/free(). */ /* The global allocator used by upb. Uses the standard malloc()/free(). */
#ifdef __cplusplus
extern "C" {
#endif
extern upb_alloc upb_alloc_global; extern upb_alloc upb_alloc_global;
#ifdef __cplusplus
} /* extern "C" */
#endif
/* Functions that hard-code the global malloc. /* Functions that hard-code the global malloc.
* *
* We still get benefit because we can put custom logic into our global * We still get benefit because we can put custom logic into our global
@ -222,7 +230,7 @@ UPB_INLINE void *upb_arena_realloc(upb_arena *a, void *ptr, size_t oldsize,
return upb_realloc(upb_arena_alloc(a), ptr, oldsize, size); return upb_realloc(upb_arena_alloc(a), ptr, oldsize, size);
} }
UPB_INLINE upb_arena *upb_arena_new() { UPB_INLINE upb_arena *upb_arena_new(void) {
return upb_arena_init(NULL, 0, &upb_alloc_global); return upb_arena_init(NULL, 0, &upb_alloc_global);
} }
@ -287,7 +295,7 @@ template <int N> class upb::InlinedArena : public upb::Arena {
/* Constants ******************************************************************/ /* Constants ******************************************************************/
/* Generic function type. */ /* Generic function type. */
typedef void upb_func(); typedef void upb_func(void);
/* A list of types as they are encoded on-the-wire. */ /* A list of types as they are encoded on-the-wire. */
typedef enum { typedef enum {

Write Preview
Loading…
Cancel
Save