Sync from internal Google development.

pull/13171/head
Josh Haberman 11 years ago
parent 2d10fa3307
commit 47b5e0968a
  1. 15
      tests/test_cpp.cc
  2. 139
      tools/dump_cinit.lua
  3. 8
      upb/bindings/stdc/error.h
  4. 8
      upb/bindings/stdc/io.h
  5. 34
      upb/def.c
  6. 276
      upb/def.h
  7. 310
      upb/descriptor/descriptor.upb.h
  8. 2
      upb/descriptor/reader.c
  9. 31
      upb/descriptor/reader.h
  10. 20
      upb/handlers-inl.h
  11. 6
      upb/handlers.c
  12. 92
      upb/handlers.h
  13. 29
      upb/json/typed_printer.h
  14. 107
      upb/pb/decoder.h
  15. 24
      upb/pb/textprinter.h
  16. 26
      upb/refcounted.h
  17. 14
      upb/shim/shim.h
  18. 93
      upb/sink.h
  19. 53
      upb/symtab.h
  20. 136
      upb/upb.h

@ -1129,21 +1129,6 @@ int run_tests(int argc, char *argv[]) {
TestHandlerDataDestruction();
#ifdef UPB_CXX11
#define ASSERT_STD_LAYOUT(type) \
static_assert(std::is_standard_layout<type>::value, \
#type " must be standard layout");
ASSERT_STD_LAYOUT(upb::RefCounted);
ASSERT_STD_LAYOUT(upb::Def);
ASSERT_STD_LAYOUT(upb::MessageDef);
ASSERT_STD_LAYOUT(upb::FieldDef);
ASSERT_STD_LAYOUT(upb::EnumDef);
ASSERT_STD_LAYOUT(upb::Handlers);
ASSERT_STD_LAYOUT(upb::SymbolTable);
ASSERT_STD_LAYOUT(upb::pb::Decoder);
ASSERT_STD_LAYOUT(upb::descriptor::Reader);
#endif
return 0;
}

@ -37,6 +37,16 @@ function export.file_appender(file)
return append
end
function handler_types(base)
local ret = {}
for k, _ in pairs(base) do
if string.find(k, "^" .. "HANDLER_") then
ret[#ret + 1] = k
end
end
return ret
end
-- const(f, label) -> UPB_LABEL_REPEATED, where f:label() == upb.LABEL_REPEATED
function const(obj, name, base)
local val = obj[name]
@ -65,6 +75,19 @@ function sortedkeys(tab)
return arr
end
function sorted_defs(defs)
local sorted = {}
for def in defs do
sorted[#sorted + 1] = def
end
table.sort(sorted,
function(a, b) return a:full_name() < b:full_name() end)
return sorted
end
function constlist(pattern)
local ret = {}
for k, v in pairs(upb) do
@ -274,6 +297,8 @@ local function to_preproc(...)
return string.upper(to_cident(...))
end
-- Strips away last path element, ie:
-- foo.Bar.Baz -> foo.Bar
local function getpackage(name)
local package_end = 0
for i=1,string.len(name) do
@ -284,11 +309,19 @@ local function getpackage(name)
return string.sub(name, 1, package_end)
end
-- Returns only the last path element, ie:
-- foo.Bar.Baz -> Baz
local function relname(name)
local package = getpackage(name)
return string.sub(name, string.len(package) + 2)
end
local function strip_prefix(prefix, str)
assert(string.sub(str, 1, string.len(prefix)) == prefix)
return string.sub(str, string.len(prefix) + 1)
end
local function start_namespace(package, append)
local package_components = split(package)
for _, component in ipairs(package_components) do
@ -495,19 +528,96 @@ local function dump_defs_c(symtab, basename, namespace, append)
end
local function dump_defs_for_type(format, defs, namespace, append)
local sorted_defs = {}
for def in defs do
sorted_defs[#sorted_defs + 1] = def
local sorted = sorted_defs(defs)
for _, def in ipairs(sorted) do
append(format, namespace, to_cident(def:full_name()), def:full_name())
end
table.sort(sorted_defs,
function(a, b) return a:full_name() < b:full_name() end)
append("\n")
end
for _, def in ipairs(sorted_defs) do
append(format, namespace, to_cident(def:full_name()), def:full_name())
local function dump_enum_vals(enumdef, append)
local enum_vals = {}
for k, v in enumdef:values() do
enum_vals[#enum_vals + 1] = {k, v}
end
table.sort(enum_vals, function(a, b) return a[2] < b[2] end)
-- protobuf convention is that enum values are scoped at the level of the
-- enum itself, to follow C++. Ie, if you have the enum:
-- message Foo {
-- enum E {
-- VAL1 = 1;
-- VAL2 = 2;
-- }
-- }
--
-- The name of VAL1 is Foo.VAL1, not Foo.E.VAL1.
--
-- This seems a bit sketchy, but people often name their enum values
-- accordingly, ie:
--
-- enum Foo {
-- FOO_VAL1 = 1;
-- FOO_VAL2 = 2;
-- }
--
-- So if we don't respect this also, we end up with constants that look like:
--
-- GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_DOUBLE = 1
--
-- (notice the duplicated "TYPE").
local cident = to_cident(getpackage(enumdef:full_name()))
for _, pair in ipairs(enum_vals) do
k, v = pair[1], pair[2]
append(' %s = %d,\n', to_preproc(cident, k), v)
end
end
local function dump_selectors(msgdef, append, base)
local selectors = {}
local types = handler_types(base)
for f in msgdef:fields() do
for _, handler_type in ipairs(types) do
local sel = f:getsel(base[handler_type])
if sel then
selectors[#selectors + 1] = {
f:name() .. "_" .. strip_prefix("HANDLER_", handler_type),
sel
}
end
end
end
table.sort(selectors, function(a, b) return a[2] < b[2] end)
-- This is kind of gross, but unless we add something to selectors to
-- distinguish them from enum values, we get conflicts like this:
--
-- // This can be either the enum value:
-- package google.protobuf;
-- message FieldDescriptorProto {
-- enum Type {
-- TYPE_INT32 = X;
-- }
-- optional Type type = 1;
-- }
--
-- // Now this can be either the enum value or the selector for the
-- // int32 handler for the "type" field.
-- GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_INT32
--
-- // So instead we make the latter the very beautiful:
-- SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_INT32
append("// %s\n", msgdef:full_name())
local cident = to_cident(msgdef:full_name())
for _, pair in ipairs(selectors) do
k, v = pair[1], pair[2]
append('#define SEL_%s %d\n', to_preproc(cident, k), v)
end
append("\n")
end
@ -538,16 +648,21 @@ local function dump_defs_h(symtab, basename, namespace, append, linktab)
end
-- Dump C enums for proto enums.
append("// Enums\n\n")
for def in symtab:defs(upb.DEF_ENUM) do
for _, def in ipairs(sorted_defs(symtab:defs(upb.DEF_ENUM))) do
local cident = to_cident(def:full_name())
append('typedef enum {\n')
for k, v in def:values() do
append(' %s = %d,\n', to_preproc(cident, k), v)
end
dump_enum_vals(def, append)
append('} %s;\n\n', cident)
end
-- selectors
append("// Selectors\n\n")
for _, def in ipairs(sorted_defs(symtab:defs(upb.DEF_MSG))) do
dump_selectors(def, append, upb)
end
append("const upb_symtab *%s_%s(const void *owner);" ..
"\n\n", namespace, to_cident(basename))

@ -12,16 +12,12 @@
#ifndef UPB_STDC_ERROR_H_
#define UPB_STDC_ERROR_H_
#ifdef __cplusplus
extern "C" {
#endif
UPB_BEGIN_EXTERN_C
extern upb_errorspace upb_stdc_errorspace;
void upb_status_fromerrno(upb_status *status, int code);
bool upb_errno_is_wouldblock(int code);
#ifdef __cplusplus
} /* extern "C" */
#endif
UPB_END_EXTERN_C
#endif /* UPB_STDC_ERROR_H_ */

@ -13,9 +13,7 @@
#include <stdio.h>
#include "upb/bytestream.h"
#ifdef __cplusplus
extern "C" {
#endif
UPB_BEGIN_EXTERN_C
/* upb_stdio ******************************************************************/
@ -66,8 +64,6 @@ void upb_stdio_open(upb_stdio *stdio, const char *filename, const char *mode,
upb_bytesrc *upb_stdio_bytesrc(upb_stdio *stdio);
upb_bytesink *upb_stdio_bytesink(upb_stdio *stdio);
#ifdef __cplusplus
} /* extern "C" */
#endif
UPB_END_EXTERN_C
#endif /* UPB_STDC_IO_H_ */

@ -275,6 +275,40 @@ static bool assign_msg_indices(upb_msgdef *m, upb_status *s) {
}
m->selector_count = selector;
#ifndef NDEBUG
// Verify that all selectors for the message are distinct.
//
#define TRY(type) \
if (upb_handlers_getselector(f, type, &sel)) upb_inttable_insert(&t, sel, v);
upb_inttable t;
upb_inttable_init(&t, UPB_CTYPE_BOOL);
upb_value v = upb_value_bool(true);
upb_selector_t sel;
upb_inttable_insert(&t, UPB_STARTMSG_SELECTOR, v);
upb_inttable_insert(&t, UPB_ENDMSG_SELECTOR, v);
for(upb_msg_begin(&j, m); !upb_msg_done(&j); upb_msg_next(&j)) {
upb_fielddef *f = upb_msg_iter_field(&j);
// These calls will assert-fail in upb_table if the value already exists.
TRY(UPB_HANDLER_INT32);
TRY(UPB_HANDLER_INT64)
TRY(UPB_HANDLER_UINT32)
TRY(UPB_HANDLER_UINT64)
TRY(UPB_HANDLER_FLOAT)
TRY(UPB_HANDLER_DOUBLE)
TRY(UPB_HANDLER_BOOL)
TRY(UPB_HANDLER_STARTSTR)
TRY(UPB_HANDLER_STRING)
TRY(UPB_HANDLER_ENDSTR)
TRY(UPB_HANDLER_STARTSUBMSG)
TRY(UPB_HANDLER_ENDSUBMSG)
TRY(UPB_HANDLER_STARTSEQ)
TRY(UPB_HANDLER_ENDSEQ)
}
upb_inttable_uninit(&t);
#undef TRY
#endif
free(fields);
return true;
}

@ -35,23 +35,13 @@ class EnumDef;
class FieldDef;
class MessageDef;
}
typedef upb::Def upb_def;
typedef upb::EnumDef upb_enumdef;
typedef upb::FieldDef upb_fielddef;
typedef upb::MessageDef upb_msgdef;
#else
struct upb_def;
struct upb_enumdef;
struct upb_fielddef;
struct upb_msgdef;
typedef struct upb_def upb_def;
typedef struct upb_enumdef upb_enumdef;
typedef struct upb_fielddef upb_fielddef;
typedef struct upb_msgdef upb_msgdef;
#endif
UPB_DECLARE_TYPE(upb::Def, upb_def);
UPB_DECLARE_TYPE(upb::EnumDef, upb_enumdef);
UPB_DECLARE_TYPE(upb::FieldDef, upb_fielddef);
UPB_DECLARE_TYPE(upb::MessageDef, upb_msgdef);
// Maximum field number allowed for FieldDefs. This is an inherent limit of the
// protobuf wire format.
#define UPB_MAX_FIELDNUMBER ((1 << 29) - 1)
@ -78,11 +68,9 @@ typedef enum {
UPB_DEF_ANY = -1, // Wildcard for upb_symtab_get*()
} upb_deftype_t;
#ifdef __cplusplus
// The base class of all defs. Its base is upb::RefCounted (use upb::upcast()
// to convert).
class upb::Def /* : public upb::Refcounted */ {
UPB_DEFINE_CLASS1(upb::Def, upb::RefCounted,
public:
typedef upb_deftype_t Type;
@ -123,11 +111,8 @@ class upb::Def /* : public upb::Refcounted */ {
private:
UPB_DISALLOW_POD_OPS(Def, upb::Def);
#else
struct upb_def {
#endif
upb_refcounted base;
,
UPB_DEFINE_STRUCT(upb_def, upb_refcounted,
const char *fullname;
upb_deftype_t type : 8;
// Used as a flag during the def's mutable stage. Must be false unless
@ -135,15 +120,14 @@ struct upb_def {
// us to easily determine which defs were passed into the function's
// current invocation.
bool came_from_user;
};
));
#define UPB_DEF_INIT(name, type, refs, ref2s) \
{ UPB_REFCOUNT_INIT(refs, ref2s), name, type, false }
UPB_BEGIN_EXTERN_C // {
// Native C API.
#ifdef __cplusplus
extern "C" {
#endif
upb_def *upb_def_dup(const upb_def *def, const void *owner);
// From upb_refcounted.
@ -157,10 +141,70 @@ upb_deftype_t upb_def_type(const upb_def *d);
const char *upb_def_fullname(const upb_def *d);
bool upb_def_setfullname(upb_def *def, const char *fullname, upb_status *s);
bool upb_def_freeze(upb_def *const *defs, int n, upb_status *s);
UPB_END_EXTERN_C // }
/* upb::Def casts *************************************************************/
#ifdef __cplusplus
} // extern "C"
#define UPB_CPP_CASTS(cname, cpptype) \
namespace upb { \
template <> \
inline cpptype *down_cast<cpptype *, Def>(Def * def) { \
return upb_downcast_##cname##_mutable(def); \
} \
template <> \
inline cpptype *dyn_cast<cpptype *, Def>(Def * def) { \
return upb_dyncast_##cname##_mutable(def); \
} \
template <> \
inline const cpptype *down_cast<const cpptype *, const Def>( \
const Def *def) { \
return upb_downcast_##cname(def); \
} \
template <> \
inline const cpptype *dyn_cast<const cpptype *, const Def>(const Def *def) { \
return upb_dyncast_##cname(def); \
} \
template <> \
inline const cpptype *down_cast<const cpptype *, Def>(Def * def) { \
return upb_downcast_##cname(def); \
} \
template <> \
inline const cpptype *dyn_cast<const cpptype *, Def>(Def * def) { \
return upb_dyncast_##cname(def); \
} \
} // namespace upb
#else
#define UPB_CPP_CASTS(cname, cpptype)
#endif
// Dynamic casts, for determining if a def is of a particular type at runtime.
// Downcasts, for when some wants to assert that a def is of a particular type.
// These are only checked if we are building debug.
#define UPB_DEF_CASTS(lower, upper, cpptype) \
UPB_INLINE const upb_##lower *upb_dyncast_##lower(const upb_def *def) { \
if (upb_def_type(def) != UPB_DEF_##upper) return NULL; \
return (upb_##lower *)def; \
} \
UPB_INLINE const upb_##lower *upb_downcast_##lower(const upb_def *def) { \
assert(upb_def_type(def) == UPB_DEF_##upper); \
return (const upb_##lower *)def; \
} \
UPB_INLINE upb_##lower *upb_dyncast_##lower##_mutable(upb_def *def) { \
return (upb_##lower *)upb_dyncast_##lower(def); \
} \
UPB_INLINE upb_##lower *upb_downcast_##lower##_mutable(upb_def *def) { \
return (upb_##lower *)upb_downcast_##lower(def); \
} \
UPB_CPP_CASTS(lower, cpptype)
#define UPB_DEFINE_DEF(cppname, lower, upper, cppmethods, members) \
UPB_DEFINE_CLASS2(cppname, upb::Def, upb::RefCounted, UPB_QUOTE(cppmethods), \
members) \
UPB_DEF_CASTS(lower, upper, cppname)
/* upb::FieldDef **************************************************************/
@ -218,14 +262,13 @@ typedef enum {
UPB_DESCRIPTOR_TYPE_SINT64 = 18,
} upb_descriptortype_t;
#ifdef __cplusplus
// A upb_fielddef describes a single field in a message. It is most often
// found as a part of a upb_msgdef, but can also stand alone to represent
// an extension.
//
// Its base class is upb::Def (use upb::upcast() to convert).
class upb::FieldDef /* : public upb::Def */ {
UPB_DEFINE_DEF(upb::FieldDef, fielddef, FIELD,
public:
typedef upb_fieldtype_t Type;
typedef upb_label_t Label;
@ -449,11 +492,8 @@ class upb::FieldDef /* : public upb::Def */ {
private:
UPB_DISALLOW_POD_OPS(FieldDef, upb::FieldDef);
#else
struct upb_fielddef {
#endif
upb_def base;
,
UPB_DEFINE_STRUCT(upb_fielddef, upb_def,
union {
int64_t sint;
uint64_t uint;
@ -482,7 +522,7 @@ struct upb_fielddef {
uint32_t number_;
uint32_t selector_base; // Used to index into a upb::Handlers table.
uint32_t index_;
};
));
#define UPB_FIELDDEF_INIT(label, type, intfmt, tagdelim, is_extension, lazy, \
name, num, msgdef, subdef, selector_base, index, \
@ -494,10 +534,9 @@ struct upb_fielddef {
lazy, intfmt, tagdelim, type, label, num, selector_base, index \
}
UPB_BEGIN_EXTERN_C // {
// Native C API.
#ifdef __cplusplus
extern "C" {
#endif
upb_fielddef *upb_fielddef_new(const void *owner);
upb_fielddef *upb_fielddef_dup(const upb_fielddef *f, const void *owner);
@ -584,21 +623,17 @@ bool upb_fielddef_checktype(int32_t type);
bool upb_fielddef_checkdescriptortype(int32_t type);
bool upb_fielddef_checkintfmt(int32_t fmt);
#ifdef __cplusplus
} // extern "C"
#endif
UPB_END_EXTERN_C // }
/* upb::MessageDef ************************************************************/
typedef upb_inttable_iter upb_msg_iter;
#ifdef __cplusplus
// Structure that describes a single .proto message type.
//
// Its base class is upb::Def (use upb::upcast() to convert).
class upb::MessageDef /* : public upb::Def */ {
UPB_DEFINE_DEF(upb::MessageDef, msgdef, MSG, UPB_QUOTE(
public:
// Returns NULL if memory allocation failed.
static reffed_ptr<MessageDef> New();
@ -684,11 +719,8 @@ class upb::MessageDef /* : public upb::Def */ {
private:
UPB_DISALLOW_POD_OPS(MessageDef, upb::MessageDef);
#else
struct upb_msgdef {
#endif
upb_def base;
),
UPB_DEFINE_STRUCT(upb_msgdef, upb_def,
size_t selector_count;
uint32_t submsg_field_count;
@ -697,7 +729,7 @@ struct upb_msgdef {
upb_strtable ntof; // name to field
// TODO(haberman): proper extension ranges (there can be multiple).
};
));
#define UPB_MSGDEF_INIT(name, selector_count, submsg_field_count, itof, ntof, \
refs, ref2s) \
@ -706,9 +738,8 @@ struct upb_msgdef {
submsg_field_count, itof, ntof \
}
#ifdef __cplusplus
extern "C" {
#endif
UPB_BEGIN_EXTERN_C // {
// Returns NULL if memory allocation failed.
upb_msgdef *upb_msgdef_new(const void *owner);
@ -748,20 +779,17 @@ void upb_msg_next(upb_msg_iter *iter);
bool upb_msg_done(const upb_msg_iter *iter);
upb_fielddef *upb_msg_iter_field(const upb_msg_iter *iter);
void upb_msg_iter_setdone(upb_msg_iter *iter);
#ifdef __cplusplus
} // extern "C
#endif
UPB_END_EXTERN_C // }
/* upb::EnumDef ***************************************************************/
typedef upb_strtable_iter upb_enum_iter;
#ifdef __cplusplus
// Class that represents an enum. Its base class is upb::Def (convert with
// upb::upcast()).
class upb::EnumDef /* : public upb::Def */ {
UPB_DEFINE_DEF(upb::EnumDef, enumdef, ENUM,
public:
// Returns NULL if memory allocation failed.
static reffed_ptr<EnumDef> New();
@ -832,23 +860,19 @@ class upb::EnumDef /* : public upb::Def */ {
private:
UPB_DISALLOW_POD_OPS(EnumDef, upb::EnumDef);
#else
struct upb_enumdef {
#endif
upb_def base;
,
UPB_DEFINE_STRUCT(upb_enumdef, upb_def,
upb_strtable ntoi;
upb_inttable iton;
int32_t defaultval;
};
));
#define UPB_ENUMDEF_INIT(name, ntoi, iton, defaultval, refs, ref2s) \
{ UPB_DEF_INIT(name, UPB_DEF_ENUM, refs, ref2s), ntoi, iton, defaultval }
UPB_BEGIN_EXTERN_C // {
// Native C API.
#ifdef __cplusplus
extern "C" {
#endif
upb_enumdef *upb_enumdef_new(const void *owner);
upb_enumdef *upb_enumdef_dup(const upb_enumdef *e, const void *owner);
@ -883,117 +907,9 @@ void upb_enum_next(upb_enum_iter *iter);
bool upb_enum_done(upb_enum_iter *iter);
const char *upb_enum_iter_name(upb_enum_iter *iter);
int32_t upb_enum_iter_number(upb_enum_iter *iter);
#ifdef __cplusplus
} // extern "C"
#endif
/* upb_def casts **************************************************************/
#ifdef __cplusplus
namespace upb {
template<>
class Pointer<Def> {
public:
explicit Pointer(Def* ptr) : ptr_(ptr) {}
operator Def*() { return ptr_; }
operator RefCounted*() { return UPB_UPCAST(ptr_); }
private:
Def* ptr_;
};
template<>
class Pointer<const Def> {
public:
explicit Pointer(const Def* ptr) : ptr_(ptr) {}
operator const Def*() { return ptr_; }
operator const RefCounted*() { return UPB_UPCAST(ptr_); }
private:
const Def* ptr_;
};
} // namespace upb
#define UPB_CPP_CASTS(cname, cpptype) \
namespace upb { \
template <> \
class Pointer<cpptype> { \
public: \
explicit Pointer(cpptype* ptr) : ptr_(ptr) {} \
operator cpptype*() { return ptr_; } \
operator Def*() { return UPB_UPCAST(ptr_); } \
operator RefCounted*() { return Pointer<Def>(UPB_UPCAST(ptr_)); } \
private: \
cpptype* ptr_; \
}; \
template <> \
class Pointer<const cpptype> { \
public: \
explicit Pointer(const cpptype* ptr) : ptr_(ptr) {} \
operator const cpptype*() { return ptr_; } \
operator const Def*() { return UPB_UPCAST(ptr_); } \
operator const RefCounted*() { \
return Pointer<const Def>(UPB_UPCAST(ptr_)); \
} \
private: \
const cpptype* ptr_; \
}; \
template <> \
inline cpptype *down_cast<cpptype*, Def>(Def *def) { \
return upb_downcast_##cname##_mutable(def); \
} \
template <> \
inline cpptype *dyn_cast<cpptype*, Def>(Def *def) { \
return upb_dyncast_##cname##_mutable(def); \
} \
template <> \
inline const cpptype *down_cast<const cpptype*, const Def>(const Def *def) { \
return upb_downcast_##cname(def); \
} \
template <> \
inline const cpptype *dyn_cast<const cpptype*, const Def>(const Def *def) { \
return upb_dyncast_##cname(def); \
} \
template <> \
inline const cpptype *down_cast<const cpptype*, Def>(Def *def) { \
return upb_downcast_##cname(def); \
} \
template <> \
inline const cpptype *dyn_cast<const cpptype*, Def>(Def *def) { \
return upb_dyncast_##cname(def); \
} \
} // namespace upb
#else
#define UPB_CPP_CASTS(cname, cpptype)
#endif
// Dynamic casts, for determining if a def is of a particular type at runtime.
// Downcasts, for when some wants to assert that a def is of a particular type.
// These are only checked if we are building debug.
#define UPB_DEF_CASTS(lower, upper, cpptype) \
UPB_INLINE const upb_##lower *upb_dyncast_##lower(const upb_def *def) { \
if (upb_def_type(def) != UPB_DEF_##upper) return NULL; \
return (upb_##lower *)def; \
} \
UPB_INLINE const upb_##lower *upb_downcast_##lower(const upb_def *def) { \
assert(upb_def_type(def) == UPB_DEF_##upper); \
return (const upb_##lower *)def; \
} \
UPB_INLINE upb_##lower *upb_dyncast_##lower##_mutable(upb_def *def) { \
return (upb_##lower *)upb_dyncast_##lower(def); \
} \
UPB_INLINE upb_##lower *upb_downcast_##lower##_mutable(upb_def *def) { \
return (upb_##lower *)upb_downcast_##lower(def); \
} \
UPB_CPP_CASTS(lower, cpptype)
UPB_END_EXTERN_C // }
UPB_DEF_CASTS(msgdef, MSG, MessageDef);
UPB_DEF_CASTS(fielddef, FIELD, FieldDef);
UPB_DEF_CASTS(enumdef, ENUM, EnumDef);
#undef UPB_DEF_CASTS
#ifdef __cplusplus
@ -1404,4 +1320,8 @@ inline void EnumDef::Iterator::Next() { return upb_enum_next(&iter_); }
} // namespace upb
#endif
#undef UPB_DEFINE_DEF
#undef UPB_DEF_CASTS
#undef UPB_CPP_CASTS
#endif /* UPB_DEF_H_ */

@ -21,44 +21,296 @@ extern "C" {
// Enums
typedef enum {
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_FIXED64 = 6,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_STRING = 9,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_FLOAT = 2,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_DOUBLE = 1,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_INT32 = 5,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_SFIXED32 = 15,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_FIXED32 = 7,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_MESSAGE = 11,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_INT64 = 3,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_ENUM = 14,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_UINT32 = 13,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_UINT64 = 4,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_SFIXED64 = 16,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_BYTES = 12,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_SINT64 = 18,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_BOOL = 8,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_GROUP = 10,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_TYPE_SINT32 = 17,
} google_protobuf_FieldDescriptorProto_Type;
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_OPTIONAL = 1,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_REQUIRED = 2,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_REPEATED = 3,
} google_protobuf_FieldDescriptorProto_Label;
typedef enum {
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_LABEL_REQUIRED = 2,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_LABEL_REPEATED = 3,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_LABEL_OPTIONAL = 1,
} google_protobuf_FieldDescriptorProto_Label;
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_DOUBLE = 1,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_FLOAT = 2,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_INT64 = 3,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_UINT64 = 4,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_INT32 = 5,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_FIXED64 = 6,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_FIXED32 = 7,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_BOOL = 8,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_STRING = 9,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_GROUP = 10,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_MESSAGE = 11,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_BYTES = 12,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_UINT32 = 13,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_ENUM = 14,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_SFIXED32 = 15,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_SFIXED64 = 16,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_SINT32 = 17,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_SINT64 = 18,
} google_protobuf_FieldDescriptorProto_Type;
typedef enum {
GOOGLE_PROTOBUF_FIELDOPTIONS_CTYPE_CORD = 1,
GOOGLE_PROTOBUF_FIELDOPTIONS_CTYPE_STRING = 0,
GOOGLE_PROTOBUF_FIELDOPTIONS_CTYPE_STRING_PIECE = 2,
GOOGLE_PROTOBUF_FIELDOPTIONS_STRING = 0,
GOOGLE_PROTOBUF_FIELDOPTIONS_CORD = 1,
GOOGLE_PROTOBUF_FIELDOPTIONS_STRING_PIECE = 2,
} google_protobuf_FieldOptions_CType;
typedef enum {
GOOGLE_PROTOBUF_FILEOPTIONS_OPTIMIZEMODE_CODE_SIZE = 2,
GOOGLE_PROTOBUF_FILEOPTIONS_OPTIMIZEMODE_SPEED = 1,
GOOGLE_PROTOBUF_FILEOPTIONS_OPTIMIZEMODE_LITE_RUNTIME = 3,
GOOGLE_PROTOBUF_FILEOPTIONS_SPEED = 1,
GOOGLE_PROTOBUF_FILEOPTIONS_CODE_SIZE = 2,
GOOGLE_PROTOBUF_FILEOPTIONS_LITE_RUNTIME = 3,
} google_protobuf_FileOptions_OptimizeMode;
// Selectors
// google.protobuf.DescriptorProto
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_FIELD_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NESTED_TYPE_STARTSUBMSG 3
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_ENUM_TYPE_STARTSUBMSG 4
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_RANGE_STARTSUBMSG 5
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_STARTSUBMSG 6
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_OPTIONS_STARTSUBMSG 7
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_FIELD_STARTSEQ 8
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_FIELD_ENDSEQ 9
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_FIELD_ENDSUBMSG 10
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NESTED_TYPE_STARTSEQ 11
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NESTED_TYPE_ENDSEQ 12
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NESTED_TYPE_ENDSUBMSG 13
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_ENUM_TYPE_STARTSEQ 14
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_ENUM_TYPE_ENDSEQ 15
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_ENUM_TYPE_ENDSUBMSG 16
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_RANGE_STARTSEQ 17
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_RANGE_ENDSEQ 18
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_RANGE_ENDSUBMSG 19
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_STARTSEQ 20
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_ENDSEQ 21
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSION_ENDSUBMSG 22
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_OPTIONS_ENDSUBMSG 23
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NAME_STRING 24
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NAME_STARTSTR 25
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_NAME_ENDSTR 26
// google.protobuf.DescriptorProto.ExtensionRange
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSIONRANGE_START_INT32 2
#define SEL_GOOGLE_PROTOBUF_DESCRIPTORPROTO_EXTENSIONRANGE_END_INT32 3
// google.protobuf.EnumDescriptorProto
#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_VALUE_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 3
#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_VALUE_STARTSEQ 4
#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_VALUE_ENDSEQ 5
#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_VALUE_ENDSUBMSG 6
#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 7
#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_NAME_STRING 8
#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_NAME_STARTSTR 9
#define SEL_GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_NAME_ENDSTR 10
// google.protobuf.EnumOptions
#define SEL_GOOGLE_PROTOBUF_ENUMOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_ENUMOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
#define SEL_GOOGLE_PROTOBUF_ENUMOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
#define SEL_GOOGLE_PROTOBUF_ENUMOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
#define SEL_GOOGLE_PROTOBUF_ENUMOPTIONS_ALLOW_ALIAS_BOOL 6
// google.protobuf.EnumValueDescriptorProto
#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 3
#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NAME_STRING 4
#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NAME_STARTSTR 5
#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NAME_ENDSTR 6
#define SEL_GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NUMBER_INT32 7
// google.protobuf.EnumValueOptions
#define SEL_GOOGLE_PROTOBUF_ENUMVALUEOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_ENUMVALUEOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
#define SEL_GOOGLE_PROTOBUF_ENUMVALUEOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
#define SEL_GOOGLE_PROTOBUF_ENUMVALUEOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
// google.protobuf.FieldDescriptorProto
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 3
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NAME_STRING 4
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NAME_STARTSTR 5
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NAME_ENDSTR 6
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_EXTENDEE_STRING 7
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_EXTENDEE_STARTSTR 8
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_EXTENDEE_ENDSTR 9
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NUMBER_INT32 10
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_INT32 11
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_INT32 12
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_NAME_STRING 13
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_NAME_STARTSTR 14
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_NAME_ENDSTR 15
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_DEFAULT_VALUE_STRING 16
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_DEFAULT_VALUE_STARTSTR 17
#define SEL_GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_DEFAULT_VALUE_ENDSTR 18
// google.protobuf.FieldOptions
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_CTYPE_INT32 6
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_PACKED_BOOL 7
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_DEPRECATED_BOOL 8
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_LAZY_BOOL 9
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_EXPERIMENTAL_MAP_KEY_STRING 10
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_EXPERIMENTAL_MAP_KEY_STARTSTR 11
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_EXPERIMENTAL_MAP_KEY_ENDSTR 12
#define SEL_GOOGLE_PROTOBUF_FIELDOPTIONS_WEAK_BOOL 13
// google.protobuf.FileDescriptorProto
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_MESSAGE_TYPE_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ENUM_TYPE_STARTSUBMSG 3
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SERVICE_STARTSUBMSG 4
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_EXTENSION_STARTSUBMSG 5
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 6
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SOURCE_CODE_INFO_STARTSUBMSG 7
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_MESSAGE_TYPE_STARTSEQ 8
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_MESSAGE_TYPE_ENDSEQ 9
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_MESSAGE_TYPE_ENDSUBMSG 10
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ENUM_TYPE_STARTSEQ 11
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ENUM_TYPE_ENDSEQ 12
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ENUM_TYPE_ENDSUBMSG 13
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SERVICE_STARTSEQ 14
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SERVICE_ENDSEQ 15
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SERVICE_ENDSUBMSG 16
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_EXTENSION_STARTSEQ 17
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_EXTENSION_ENDSEQ 18
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_EXTENSION_ENDSUBMSG 19
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 20
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_SOURCE_CODE_INFO_ENDSUBMSG 21
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_NAME_STRING 22
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_NAME_STARTSTR 23
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_NAME_ENDSTR 24
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PACKAGE_STRING 25
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PACKAGE_STARTSTR 26
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PACKAGE_ENDSTR 27
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_DEPENDENCY_STARTSEQ 28
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_DEPENDENCY_ENDSEQ 29
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_DEPENDENCY_STRING 30
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_DEPENDENCY_STARTSTR 31
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_DEPENDENCY_ENDSTR 32
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PUBLIC_DEPENDENCY_STARTSEQ 33
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PUBLIC_DEPENDENCY_ENDSEQ 34
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PUBLIC_DEPENDENCY_INT32 35
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_WEAK_DEPENDENCY_STARTSEQ 36
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_WEAK_DEPENDENCY_ENDSEQ 37
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_WEAK_DEPENDENCY_INT32 38
// google.protobuf.FileDescriptorSet
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORSET_FILE_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORSET_FILE_STARTSEQ 3
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORSET_FILE_ENDSEQ 4
#define SEL_GOOGLE_PROTOBUF_FILEDESCRIPTORSET_FILE_ENDSUBMSG 5
// google.protobuf.FileOptions
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_PACKAGE_STRING 6
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_PACKAGE_STARTSTR 7
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_PACKAGE_ENDSTR 8
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_OUTER_CLASSNAME_STRING 9
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_OUTER_CLASSNAME_STARTSTR 10
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_OUTER_CLASSNAME_ENDSTR 11
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_OPTIMIZE_FOR_INT32 12
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_MULTIPLE_FILES_BOOL 13
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_GO_PACKAGE_STRING 14
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_GO_PACKAGE_STARTSTR 15
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_GO_PACKAGE_ENDSTR 16
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_CC_GENERIC_SERVICES_BOOL 17
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_GENERIC_SERVICES_BOOL 18
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_PY_GENERIC_SERVICES_BOOL 19
#define SEL_GOOGLE_PROTOBUF_FILEOPTIONS_JAVA_GENERATE_EQUALS_AND_HASH_BOOL 20
// google.protobuf.MessageOptions
#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_MESSAGE_SET_WIRE_FORMAT_BOOL 6
#define SEL_GOOGLE_PROTOBUF_MESSAGEOPTIONS_NO_STANDARD_DESCRIPTOR_ACCESSOR_BOOL 7
// google.protobuf.MethodDescriptorProto
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 3
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_NAME_STRING 4
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_NAME_STARTSTR 5
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_NAME_ENDSTR 6
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_INPUT_TYPE_STRING 7
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_INPUT_TYPE_STARTSTR 8
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_INPUT_TYPE_ENDSTR 9
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_OUTPUT_TYPE_STRING 10
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_OUTPUT_TYPE_STARTSTR 11
#define SEL_GOOGLE_PROTOBUF_METHODDESCRIPTORPROTO_OUTPUT_TYPE_ENDSTR 12
// google.protobuf.MethodOptions
#define SEL_GOOGLE_PROTOBUF_METHODOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_METHODOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
#define SEL_GOOGLE_PROTOBUF_METHODOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
#define SEL_GOOGLE_PROTOBUF_METHODOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
// google.protobuf.ServiceDescriptorProto
#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_METHOD_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_OPTIONS_STARTSUBMSG 3
#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_METHOD_STARTSEQ 4
#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_METHOD_ENDSEQ 5
#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_METHOD_ENDSUBMSG 6
#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_OPTIONS_ENDSUBMSG 7
#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_NAME_STRING 8
#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_NAME_STARTSTR 9
#define SEL_GOOGLE_PROTOBUF_SERVICEDESCRIPTORPROTO_NAME_ENDSTR 10
// google.protobuf.ServiceOptions
#define SEL_GOOGLE_PROTOBUF_SERVICEOPTIONS_UNINTERPRETED_OPTION_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_SERVICEOPTIONS_UNINTERPRETED_OPTION_STARTSEQ 3
#define SEL_GOOGLE_PROTOBUF_SERVICEOPTIONS_UNINTERPRETED_OPTION_ENDSEQ 4
#define SEL_GOOGLE_PROTOBUF_SERVICEOPTIONS_UNINTERPRETED_OPTION_ENDSUBMSG 5
// google.protobuf.SourceCodeInfo
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_STARTSEQ 3
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_ENDSEQ 4
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_ENDSUBMSG 5
// google.protobuf.SourceCodeInfo.Location
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_PATH_STARTSEQ 2
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_PATH_ENDSEQ 3
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_PATH_INT32 4
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_SPAN_STARTSEQ 5
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_SPAN_ENDSEQ 6
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_SPAN_INT32 7
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_LEADING_COMMENTS_STRING 8
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_LEADING_COMMENTS_STARTSTR 9
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_LEADING_COMMENTS_ENDSTR 10
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_TRAILING_COMMENTS_STRING 11
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_TRAILING_COMMENTS_STARTSTR 12
#define SEL_GOOGLE_PROTOBUF_SOURCECODEINFO_LOCATION_TRAILING_COMMENTS_ENDSTR 13
// google.protobuf.UninterpretedOption
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAME_STARTSUBMSG 2
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAME_STARTSEQ 3
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAME_ENDSEQ 4
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAME_ENDSUBMSG 5
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_IDENTIFIER_VALUE_STRING 6
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_IDENTIFIER_VALUE_STARTSTR 7
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_IDENTIFIER_VALUE_ENDSTR 8
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_POSITIVE_INT_VALUE_UINT64 9
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NEGATIVE_INT_VALUE_INT64 10
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_DOUBLE_VALUE_DOUBLE 11
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_STRING_VALUE_STRING 12
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_STRING_VALUE_STARTSTR 13
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_STRING_VALUE_ENDSTR 14
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_AGGREGATE_VALUE_STRING 15
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_AGGREGATE_VALUE_STARTSTR 16
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_AGGREGATE_VALUE_ENDSTR 17
// google.protobuf.UninterpretedOption.NamePart
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAMEPART_NAME_PART_STRING 2
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAMEPART_NAME_PART_STARTSTR 3
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAMEPART_NAME_PART_ENDSTR 4
#define SEL_GOOGLE_PROTOBUF_UNINTERPRETEDOPTION_NAMEPART_IS_EXTENSION_BOOL 5
const upb_symtab *upbdefs_google_protobuf_descriptor(const void *owner);
// MessageDefs

@ -126,7 +126,7 @@ upb_def **upb_descreader_getdefs(upb_descreader *r, void *owner, int *n) {
}
upb_sink *upb_descreader_input(upb_descreader *r) {
return (upb_sink*)r->sink;
return &r->sink;
}
static upb_msgdef *upb_descreader_top(upb_descreader *r) {

@ -19,13 +19,10 @@ namespace descriptor {
class Reader;
} // namespace descriptor
} // namespace upb
typedef upb::descriptor::Reader upb_descreader;
#else
struct upb_descreader;
typedef struct upb_descreader upb_descreader;
#endif
UPB_DECLARE_TYPE(upb::descriptor::Reader, upb_descreader);
// Internal-only structs used by Reader.
// upb_deflist is an internal-only dynamic array for storing a growing list of
@ -62,11 +59,9 @@ typedef struct {
// TODO: make this a runtime-settable property of the Reader instance.
#define UPB_MAX_MESSAGE_NESTING 64
#ifdef __cplusplus
// Class that receives descriptor data according to the descriptor.proto schema
// and use it to build upb::Defs corresponding to that schema.
class upb::descriptor::Reader {
UPB_DEFINE_CLASS0(upb::descriptor::Reader,
public:
// These handlers must have come from NewHandlers() and must outlive the
// Reader.
@ -96,12 +91,9 @@ class upb::descriptor::Reader {
// Builds and returns handlers for the reader, owned by "owner."
static Handlers* NewHandlers(const void* owner);
private:
#else
struct upb_descreader {
#endif
char sink[sizeof(upb_sink)];
,
UPB_DEFINE_STRUCT0(upb_descreader,
upb_sink sink;
upb_deflist defs;
upb_descreader_frame stack[UPB_MAX_MESSAGE_NESTING];
int stack_len;
@ -114,11 +106,9 @@ struct upb_descreader {
char *default_string;
upb_fielddef *f;
};
));
#ifdef __cplusplus
extern "C" {
#endif
UPB_BEGIN_EXTERN_C // {
// C API.
void upb_descreader_init(upb_descreader *r, const upb_handlers *handlers,
@ -129,11 +119,10 @@ upb_sink *upb_descreader_input(upb_descreader *r);
upb_def **upb_descreader_getdefs(upb_descreader *r, void *owner, int *n);
const upb_handlers *upb_descreader_newhandlers(const void *owner);
#ifdef __cplusplus
} // extern "C"
UPB_END_EXTERN_C // }
#ifdef __cplusplus
// C++ implementation details. /////////////////////////////////////////////////
namespace upb {
namespace descriptor {
inline Reader::Reader(const Handlers *h, Status *s) {

@ -128,26 +128,6 @@ UPB_INLINE const char *upb_bufhandle_buf(const upb_bufhandle *h) {
namespace upb {
template<>
class Pointer<Handlers> {
public:
explicit Pointer(Handlers* ptr) : ptr_(ptr) {}
operator Handlers*() { return ptr_; }
operator RefCounted*() { return UPB_UPCAST(ptr_); }
private:
Handlers* ptr_;
};
template<>
class Pointer<const Handlers> {
public:
explicit Pointer(const Handlers* ptr) : ptr_(ptr) {}
operator const Handlers*() { return ptr_; }
operator const RefCounted*() { return UPB_UPCAST(ptr_); }
private:
const Handlers* ptr_;
};
typedef void CleanupFunc(void *ptr);
// Template to remove "const" from "const T*" and just return "T*".

@ -523,21 +523,21 @@ bool upb_handlers_getselector(const upb_fielddef *f, upb_handlertype_t type,
case UPB_HANDLER_STRING:
if (upb_fielddef_isstring(f)) {
*s = f->selector_base;
} else if (upb_fielddef_issubmsg(f)) {
} else if (upb_fielddef_lazy(f)) {
*s = f->selector_base + 3;
} else {
return false;
}
break;
case UPB_HANDLER_STARTSTR:
if (upb_fielddef_isstring(f) || upb_fielddef_issubmsg(f)) {
if (upb_fielddef_isstring(f) || upb_fielddef_lazy(f)) {
*s = f->selector_base + 1;
} else {
return false;
}
break;
case UPB_HANDLER_ENDSTR:
if (upb_fielddef_isstring(f) || upb_fielddef_issubmsg(f)) {
if (upb_fielddef_isstring(f) || upb_fielddef_lazy(f)) {
*s = f->selector_base + 2;
} else {
return false;

@ -25,7 +25,6 @@
#include "upb/def.h"
#ifdef __cplusplus
namespace upb {
class BufferHandle;
class BytesHandler;
@ -34,24 +33,13 @@ class Handlers;
template <class T> class Handler;
template <class T> struct CanonicalType;
} // namespace upb
typedef upb::BufferHandle upb_bufhandle;
typedef upb::BytesHandler upb_byteshandler;
typedef upb::HandlerAttributes upb_handlerattr;
typedef upb::Handlers upb_handlers;
#else
struct upb_bufhandle;
struct upb_byteshandler;
struct upb_handlerattr;
struct upb_handlers;
struct upb_sinkframe;
typedef struct upb_bufhandle upb_bufhandle;
typedef struct upb_byteshandler upb_byteshandler;
typedef struct upb_handlerattr upb_handlerattr;
typedef struct upb_handlers upb_handlers;
typedef struct upb_sinkframe upb_sinkframe;
#endif
UPB_DECLARE_TYPE(upb::BufferHandle, upb_bufhandle);
UPB_DECLARE_TYPE(upb::BytesHandler, upb_byteshandler);
UPB_DECLARE_TYPE(upb::HandlerAttributes, upb_handlerattr);
UPB_DECLARE_TYPE(upb::Handlers, upb_handlers);
// The maximum depth that the handler graph can have. This is a resource limit
// for the C stack since we sometimes need to recursively traverse the graph.
// Cycles are ok; the traversal will stop when it detects a cycle, but we must
@ -92,9 +80,7 @@ extern char _upb_noclosure;
// (for example: the STARTSUBMSG handler for field "field15").
typedef int32_t upb_selector_t;
#ifdef __cplusplus
extern "C" {
#endif
UPB_BEGIN_EXTERN_C
// Forward-declares for C inline accessors. We need to declare these here
// so we can "friend" them in the class declarations in C++.
@ -113,9 +99,7 @@ UPB_INLINE const void *upb_bufhandle_obj(const upb_bufhandle *h);
UPB_INLINE const void *upb_bufhandle_objtype(const upb_bufhandle *h);
UPB_INLINE const char *upb_bufhandle_buf(const upb_bufhandle *h);
#ifdef __cplusplus
}
#endif
UPB_END_EXTERN_C
// Static selectors for upb::Handlers.
@ -130,10 +114,8 @@ UPB_INLINE const char *upb_bufhandle_buf(const upb_bufhandle *h);
typedef void upb_handlerfree(void *d);
#ifdef __cplusplus
// A set of attributes that accompanies a handler's function pointer.
class upb::HandlerAttributes {
UPB_DEFINE_CLASS0(upb::HandlerAttributes,
public:
HandlerAttributes();
~HandlerAttributes();
@ -167,15 +149,13 @@ class upb::HandlerAttributes {
private:
friend UPB_INLINE const void * ::upb_handlerattr_handlerdata(
const upb_handlerattr *attr);
#else
struct upb_handlerattr {
#endif
,
UPB_DEFINE_STRUCT0(upb_handlerattr,
const void *handler_data_;
const void *closure_type_;
const void *return_closure_type_;
bool alwaysok_;
};
));
#define UPB_HANDLERATTR_INITIALIZER {NULL, NULL, NULL, false}
@ -194,12 +174,10 @@ typedef struct {
upb_handlerattr attr;
} upb_handlers_tabent;
#ifdef __cplusplus
// Extra information about a buffer that is passed to a StringBuf handler.
// TODO(haberman): allow the handle to be pinned so that it will outlive
// the handler invocation.
class upb::BufferHandle {
UPB_DEFINE_CLASS0(upb::BufferHandle,
public:
BufferHandle();
~BufferHandle();
@ -236,16 +214,13 @@ class upb::BufferHandle {
friend UPB_INLINE const void* ::upb_bufhandle_objtype(
const upb_bufhandle *h);
friend UPB_INLINE const char* ::upb_bufhandle_buf(const upb_bufhandle *h);
#else
struct upb_bufhandle {
#endif
,
UPB_DEFINE_STRUCT0(upb_bufhandle,
const char *buf_;
const void *obj_;
const void *objtype_;
size_t objofs_;
};
#ifdef __cplusplus
));
// A upb::Handlers object represents the set of handlers associated with a
// message in the graph of messages. You can think of it as a big virtual
@ -258,7 +233,7 @@ struct upb_bufhandle {
//
// The easiest way to create the *Handler objects needed by the Set* methods is
// with the UpbBind() and UpbMakeHandler() macros; see below.
class upb::Handlers {
UPB_DEFINE_CLASS1(upb::Handlers, upb::RefCounted,
public:
typedef upb_selector_t Selector;
typedef upb_handlertype_t Type;
@ -527,17 +502,15 @@ class upb::Handlers {
friend UPB_INLINE const void *::upb_handlers_gethandlerdata(
const upb_handlers *h, upb_selector_t s);
#else
struct upb_handlers {
#endif
upb_refcounted base;
,
UPB_DEFINE_STRUCT(upb_handlers, upb_refcounted,
const upb_msgdef *msg;
const upb_handlers **sub;
const void *top_closure_type;
upb_inttable cleanup_;
upb_status status_; // Used only when mutable.
upb_handlers_tabent table[1]; // Dynamically-sized field handler array.
};
));
#ifdef __cplusplus
@ -638,9 +611,10 @@ template <class T> class Handler {
} // namespace upb
extern "C" {
#endif // __cplusplus
UPB_BEGIN_EXTERN_C
// Native C API.
// Handler function typedefs.
@ -765,24 +739,19 @@ UPB_INLINE const void *upb_handlers_gethandlerdata(const upb_handlers *h,
return upb_handlerattr_handlerdata(&h->table[s].attr);
}
#ifdef __cplusplus
// Handler types for single fields.
// Right now we only have one for TYPE_BYTES but ones for other types
// should follow.
//
// These follow the same handlers protocol for fields of a message.
class upb::BytesHandler {
UPB_DEFINE_CLASS0(upb::BytesHandler,
public:
BytesHandler();
~BytesHandler();
// TODO(haberman): make private and figure out what to friend.
#else
struct upb_byteshandler {
#endif
,
UPB_DEFINE_STRUCT0(upb_byteshandler,
upb_handlers_tabent table[3];
};
));
void upb_byteshandler_init(upb_byteshandler *h);
void upb_byteshandler_uninit(upb_byteshandler *h);
@ -799,12 +768,6 @@ bool upb_byteshandler_setstring(upb_byteshandler *h,
bool upb_byteshandler_setendstr(upb_byteshandler *h,
upb_endfield_handlerfunc *func, void *d);
#ifdef __cplusplus
namespace upb {
typedef upb_byteshandler BytesHandler;
}
#endif
// "Static" methods
bool upb_handlers_freeze(upb_handlers *const *handlers, int n, upb_status *s);
upb_handlertype_t upb_handlers_getprimitivehandlertype(const upb_fielddef *f);
@ -817,9 +780,8 @@ UPB_INLINE upb_selector_t upb_handlers_getendselector(upb_selector_t start) {
// Internal-only.
uint32_t upb_handlers_selectorbaseoffset(const upb_fielddef *f);
uint32_t upb_handlers_selectorcount(const upb_fielddef *f);
#ifdef __cplusplus
} // extern "C"
#endif
UPB_END_EXTERN_C
#include "upb/handlers-inl.h"

@ -19,20 +19,15 @@ namespace json {
class TypedPrinter;
} // namespace json
} // namespace upb
typedef upb::json::TypedPrinter upb_json_typedprinter;
#else
struct upb_json_typedprinter;
typedef struct upb_json_typedprinter upb_json_typedprinter;
#endif
UPB_DECLARE_TYPE(upb::json::TypedPrinter, upb_json_typedprinter);
/* upb::json::TypedPrinter ****************************************************/
#ifdef __cplusplus
/* upb::json::TypedPrinter ****************************************************/
// Prints an incoming stream of data to a BytesSink in JSON format.
class upb::json::TypedPrinter {
UPB_DEFINE_CLASS0(upb::json::TypedPrinter,
public:
TypedPrinter(const upb::Handlers* handlers);
~TypedPrinter();
@ -50,11 +45,8 @@ class upb::json::TypedPrinter {
// Returns handlers for printing according to the specified schema.
static reffed_ptr<const Handlers> NewHandlers(const upb::MessageDef* md);
private:
#else
struct upb_json_typedprinter {
#endif
,
UPB_DEFINE_STRUCT0(upb_json_typedprinter,
upb_sink input_;
// Pointer to yajl_gen; void* here so we don't have to include YAJL headers.
void *yajl_gen_;
@ -63,12 +55,11 @@ struct upb_json_typedprinter {
// We track the depth so that we know when to emit startstr/endstr on the
// output.
int depth_;
};
));
UPB_BEGIN_EXTERN_C // {
// Native C API.
#ifdef __cplusplus
extern "C" {
#endif
void upb_json_typedprinter_init(upb_json_typedprinter *p,
const upb_handlers *h);
@ -80,9 +71,7 @@ upb_sink *upb_json_typedprinter_input(upb_json_typedprinter *p);
const upb_handlers *upb_json_typedprinter_newhandlers(const upb_msgdef *md,
const void *owner);
#ifdef __cplusplus
} // extern "C"
#endif
UPB_END_EXTERN_C // }
#ifdef __cplusplus

@ -30,23 +30,13 @@ class DecoderMethod;
class DecoderMethodOptions;
} // namespace pb
} // namespace upb
typedef upb::pb::CodeCache upb_pbcodecache;
typedef upb::pb::Decoder upb_pbdecoder;
typedef upb::pb::DecoderMethod upb_pbdecodermethod;
typedef upb::pb::DecoderMethodOptions upb_pbdecodermethodopts;
#else
struct upb_pbdecoder;
struct upb_pbdecodermethod;
struct upb_pbdecodermethodopts;
struct upb_pbcodecache;
typedef struct upb_pbdecoder upb_pbdecoder;
typedef struct upb_pbdecodermethod upb_pbdecodermethod;
typedef struct upb_pbdecodermethodopts upb_pbdecodermethodopts;
typedef struct upb_pbcodecache upb_pbcodecache;
#endif
UPB_DECLARE_TYPE(upb::pb::CodeCache, upb_pbcodecache);
UPB_DECLARE_TYPE(upb::pb::Decoder, upb_pbdecoder);
UPB_DECLARE_TYPE(upb::pb::DecoderMethod, upb_pbdecodermethod);
UPB_DECLARE_TYPE(upb::pb::DecoderMethodOptions, upb_pbdecodermethodopts);
// The maximum that any submessages can be nested. Matches proto2's limit.
// This specifies the size of the decoder's statically-sized array and therefore
// setting it high will cause the upb::pb::Decoder object to be larger.
@ -59,20 +49,14 @@ typedef struct upb_pbcodecache upb_pbcodecache;
// Internal-only struct used by the decoder.
typedef struct {
#ifdef __cplusplus
private:
#endif
UPB_PRIVATE_FOR_CPP
// Space optimization note: we store two pointers here that the JIT
// doesn't need at all; the upb_handlers* inside the sink and
// the dispatch table pointer. We can optimze so that the JIT uses
// smaller stack frames than the interpreter. The only thing we need
// to guarantee is that the fallback routines can find end_ofs.
#ifdef __cplusplus
char sink[sizeof(upb_sink)];
#else
upb_sink sink;
#endif
// The absolute stream offset of the end-of-frame delimiter.
// Non-delimited frames (groups and non-packed repeated fields) reuse the
// delimiter of their parent, even though the frame may not end there.
@ -91,11 +75,9 @@ typedef struct {
upb_inttable *dispatch; // Not used by the JIT.
} upb_pbdecoder_frame;
#ifdef __cplusplus
// The parameters one uses to construct a DecoderMethod.
// TODO(haberman): move allowjit here? Seems more convenient for users.
class upb::pb::DecoderMethodOptions {
UPB_DEFINE_CLASS0(upb::pb::DecoderMethodOptions,
public:
// Parameter represents the destination handlers that this method will push
// to.
@ -105,19 +87,14 @@ class upb::pb::DecoderMethodOptions {
// them? The caller should set this iff the lazy handlers expect data that is
// in protobuf binary format and the caller wishes to lazy parse it.
void set_lazy(bool lazy);
private:
#else
struct upb_pbdecodermethodopts {
#endif
,
UPB_DEFINE_STRUCT0(upb_pbdecodermethodopts,
const upb_handlers *handlers;
bool lazy;
};
#ifdef __cplusplus
));
// Represents the code to parse a protobuf according to a destination Handlers.
class upb::pb::DecoderMethod /* : public upb::RefCounted */ {
UPB_DEFINE_CLASS1(upb::pb::DecoderMethod, upb::RefCounted,
public:
// From upb::ReferenceCounted.
void Ref(const void* owner) const;
@ -142,11 +119,8 @@ class upb::pb::DecoderMethod /* : public upb::RefCounted */ {
private:
UPB_DISALLOW_POD_OPS(DecoderMethod, upb::pb::DecoderMethod);
#else
struct upb_pbdecodermethod {
#endif
upb_refcounted base;
,
UPB_DEFINE_STRUCT(upb_pbdecodermethod, upb_refcounted,
// While compiling, the base is relative in "ofs", after compiling it is
// absolute in "ptr".
union {
@ -186,13 +160,11 @@ struct upb_pbdecodermethod {
// the second wire type without needing to do a separate lookup (this case is
// less common than an unknown field).
upb_inttable dispatch;
};
#ifdef __cplusplus
));
// A Decoder receives binary protobuf data on its input sink and pushes the
// decoded data to its output sink.
class upb::pb::Decoder {
UPB_DEFINE_CLASS0(upb::pb::Decoder,
public:
// Constructs a decoder instance for the given method, which must outlive this
// decoder. Any errors during parsing will be set on the given status, which
@ -230,9 +202,8 @@ class upb::pb::Decoder {
private:
UPB_DISALLOW_COPY_AND_ASSIGN(Decoder);
#else
struct upb_pbdecoder {
#endif
,
UPB_DEFINE_STRUCT0(upb_pbdecoder, UPB_QUOTE(
// Our input sink.
upb_bytessink input_;
@ -286,15 +257,13 @@ struct upb_pbdecoder {
#else
const uint32_t *callstack[UPB_DECODER_MAX_NESTING];
#endif
};
#ifdef __cplusplus
)));
// A class for caching protobuf processing code, whether bytecode for the
// interpreted decoder or machine code for the JIT.
//
// This class is not thread-safe.
class upb::pb::CodeCache {
UPB_DEFINE_CLASS0(upb::pb::CodeCache,
public:
CodeCache();
~CodeCache();
@ -327,19 +296,15 @@ class upb::pb::CodeCache {
private:
UPB_DISALLOW_COPY_AND_ASSIGN(CodeCache);
#else
struct upb_pbcodecache {
#endif
,
UPB_DEFINE_STRUCT0(upb_pbcodecache,
bool allow_jit_;
// Array of mgroups.
upb_inttable groups;
};
));
#ifdef __cplusplus
extern "C" {
#endif
UPB_BEGIN_EXTERN_C // {
void upb_pbdecoder_init(upb_pbdecoder *d, const upb_pbdecodermethod *method,
upb_status *status);
@ -375,34 +340,12 @@ bool upb_pbcodecache_setallowjit(upb_pbcodecache *c, bool allow);
const upb_pbdecodermethod *upb_pbcodecache_getdecodermethod(
upb_pbcodecache *c, const upb_pbdecodermethodopts *opts);
#ifdef __cplusplus
} /* extern "C" */
#endif
UPB_END_EXTERN_C // }
#ifdef __cplusplus
namespace upb {
template<>
class Pointer<pb::DecoderMethod> {
public:
explicit Pointer(pb::DecoderMethod* ptr) : ptr_(ptr) {}
operator pb::DecoderMethod*() { return ptr_; }
operator RefCounted*() { return UPB_UPCAST(ptr_); }
private:
pb::DecoderMethod* ptr_;
};
template<>
class Pointer<const pb::DecoderMethod> {
public:
explicit Pointer(const pb::DecoderMethod* ptr) : ptr_(ptr) {}
operator const pb::DecoderMethod*() { return ptr_; }
operator const RefCounted*() { return UPB_UPCAST(ptr_); }
private:
const pb::DecoderMethod* ptr_;
};
namespace pb {
inline Decoder::Decoder(const DecoderMethod* m, Status* s) {

@ -16,15 +16,11 @@ namespace pb {
class TextPrinter;
} // namespace pb
} // namespace upb
typedef upb::pb::TextPrinter upb_textprinter;
#else
struct upb_textprinter;
typedef struct upb_textprinter upb_textprinter;
#endif
#ifdef __cplusplus
class upb::pb::TextPrinter {
UPB_DECLARE_TYPE(upb::pb::TextPrinter, upb_textprinter);
UPB_DEFINE_CLASS0(upb::pb::TextPrinter,
public:
// The given handlers must have come from NewHandlers(). It must outlive the
// TextPrinter.
@ -40,19 +36,16 @@ class upb::pb::TextPrinter {
static reffed_ptr<const Handlers> NewHandlers(const MessageDef* md);
private:
#else
struct upb_textprinter {
#endif
,
UPB_DEFINE_STRUCT0(upb_textprinter,
upb_sink input_;
upb_bytessink *output_;
int indent_depth_;
bool single_line_;
void *subc;
};
));
#ifdef __cplusplus
extern "C" {
#endif
UPB_BEGIN_EXTERN_C // {
// C API.
void upb_textprinter_init(upb_textprinter *p, const upb_handlers *h);
@ -64,8 +57,9 @@ upb_sink *upb_textprinter_input(upb_textprinter *p);
const upb_handlers *upb_textprinter_newhandlers(const upb_msgdef *m,
const void *owner);
UPB_END_EXTERN_C // }
#ifdef __cplusplus
} /* extern "C" */
namespace upb {
namespace pb {

@ -29,20 +29,15 @@
#define UPB_DEBUG_REFS
#endif
struct upb_refcounted_vtbl;
#ifdef __cplusplus
namespace upb { class RefCounted; }
typedef upb::RefCounted upb_refcounted;
extern "C" {
#else
struct upb_refcounted;
typedef struct upb_refcounted upb_refcounted;
#endif
#ifdef __cplusplus
UPB_DECLARE_TYPE(upb::RefCounted, upb_refcounted);
struct upb_refcounted_vtbl;
class upb::RefCounted {
UPB_DEFINE_CLASS0(upb::RefCounted,
public:
// Returns true if the given object is frozen.
bool IsFrozen() const;
@ -68,9 +63,8 @@ class upb::RefCounted {
private:
UPB_DISALLOW_POD_OPS(RefCounted, upb::RefCounted);
#else
struct upb_refcounted {
#endif
,
UPB_DEFINE_STRUCT0(upb_refcounted,
// A single reference count shared by all objects in the group.
uint32_t *group;
@ -91,7 +85,9 @@ struct upb_refcounted {
upb_inttable *refs; // Maps owner -> trackedref for incoming refs.
upb_inttable *ref2s; // Set of targets for outgoing ref2s.
#endif
};
));
UPB_BEGIN_EXTERN_C // {
// Native C API.
bool upb_refcounted_isfrozen(const upb_refcounted *r);
@ -159,6 +155,8 @@ bool upb_refcounted_freeze(upb_refcounted *const*roots, int n, upb_status *s,
// Shared by all compiled-in refcounted objects.
extern uint32_t static_refcount;
UPB_END_EXTERN_C // }
#ifdef UPB_DEBUG_REFS
#define UPB_REFCOUNT_INIT(refs, ref2s) \
{&static_refcount, NULL, NULL, 0, true, refs, ref2s}
@ -167,8 +165,6 @@ extern uint32_t static_refcount;
#endif
#ifdef __cplusplus
} /* extern "C" */
// C++ Wrappers.
namespace upb {
inline bool RefCounted::IsFrozen() const {

@ -45,21 +45,21 @@ struct Shim {
} // namespace upb
extern "C" {
#endif
UPB_BEGIN_EXTERN_C // {
// C API.
bool upb_shim_set(upb_handlers *h, const upb_fielddef *f, size_t offset,
int32_t hasbit);
const upb_shim_data *upb_shim_getdata(const upb_handlers *h, upb_selector_t s,
upb_fieldtype_t *type);
#ifdef __cplusplus
} // extern "C"
namespace upb {
UPB_END_EXTERN_C // }
#ifdef __cplusplus
// C++ Wrappers.
namespace upb {
inline bool Shim::Set(Handlers* h, const FieldDef* f, size_t ofs,
int32_t hasbit) {
return upb_shim_set(h, f, ofs, hasbit);
@ -68,9 +68,7 @@ inline const Shim::Data* Shim::GetData(const Handlers* h, Handlers::Selector s,
FieldDef::Type* type) {
return upb_shim_getdata(h, s, type);
}
} // namespace
} // namespace upb
#endif
#endif // UPB_SHIM_H

@ -28,20 +28,15 @@ class BufferSource;
class BytesSink;
class Sink;
}
typedef upb::BufferSource upb_bufsrc;
typedef upb::BytesSink upb_bytessink;
typedef upb::Sink upb_sink;
#else
struct upb_sink;
struct upb_bufsrc;
struct upb_bytessink;
typedef struct upb_sink upb_sink;
typedef struct upb_bytessink upb_bytessink;
typedef struct upb_bufsrc upb_bufsrc;
#endif
UPB_DECLARE_TYPE(upb::BufferSource, upb_bufsrc);
UPB_DECLARE_TYPE(upb::BytesSink, upb_bytessink);
UPB_DECLARE_TYPE(upb::Sink, upb_sink);
// Internal-only struct for the sink.
struct upb_sinkframe {
UPB_PRIVATE_FOR_CPP
const upb_handlers *h;
void *closure;
@ -60,11 +55,43 @@ struct upb_sinkframe {
// TODO: make this a runtime-settable property of Sink.
#define UPB_SINK_MAX_NESTING 64
#ifdef __cplusplus
// A upb::Sink is an object that binds a upb::Handlers object to some runtime
// state. It represents an endpoint to which data can be sent.
class upb::Sink {
//
// TODO(haberman): right now all of these functions take selectors. Should they
// take selectorbase instead?
//
// ie. instead of calling:
// sink->StartString(FOO_FIELD_START_STRING, ...)
// a selector base would let you say:
// sink->StartString(FOO_FIELD, ...)
//
// This would make call sites a little nicer and require emitting fewer selector
// definitions in .h files.
//
// But the current scheme has the benefit that you can retrieve a function
// pointer for any handler with handlers->GetHandler(selector), without having
// to have a separate GetHandler() function for each handler type. The JIT
// compiler uses this. To accommodate we'd have to expose a separate
// GetHandler() for every handler type.
//
// Also to ponder: selectors right now are independent of a specific Handlers
// instance. In other words, they allocate a number to every possible handler
// that *could* be registered, without knowing anything about what handlers
// *are* registered. That means that using selectors as table offsets prohibits
// us from compacting the handler table at Freeze() time. If the table is very
// sparse, this could be wasteful.
//
// Having another selector-like thing that is specific to a Handlers instance
// would allow this compacting, but then it would be impossible to write code
// ahead-of-time that can be bound to any Handlers instance at runtime. For
// example, a .proto file parser written as straight C will not know what
// Handlers it will be bound to, so when it calls sink->StartString() what
// selector will it pass? It needs a selector like we have today, that is
// independent of any particular upb::Handlers.
//
// Is there a way then to allow Handlers table compaction?
UPB_DEFINE_CLASS0(upb::Sink,
public:
// Constructor with no initialization; must be Reset() before use.
Sink() {}
@ -144,16 +171,13 @@ class upb::Sink {
// Copy and assign specifically allowed.
// We don't even bother making these members private because so many
// functions need them and this is mainly just a dumb data container anyway.
#else
struct upb_sink {
#endif
,
UPB_DEFINE_STRUCT0(upb_sink,
const upb_handlers *handlers;
void *closure;
};
));
#ifdef __cplusplus
class upb::BytesSink {
UPB_DEFINE_CLASS0(upb::BytesSink,
public:
BytesSink() {}
@ -170,20 +194,16 @@ class upb::BytesSink {
size_t PutBuffer(void *subc, const char *buf, size_t len,
const BufferHandle *handle);
bool End();
#else
struct upb_bytessink {
#endif
,
UPB_DEFINE_STRUCT0(upb_bytessink,
const upb_byteshandler *handler;
void *closure;
};
#ifdef __cplusplus
));
// A class for pushing a flat buffer of data to a BytesSink.
// You can construct an instance of this to get a resumable source,
// or just call the static PutBuffer() to do a non-resumable push all in one go.
class upb::BufferSource {
UPB_DEFINE_CLASS0(upb::BufferSource,
public:
BufferSource();
BufferSource(const char* buf, size_t len, BytesSink* sink);
@ -200,16 +220,11 @@ class upb::BufferSource {
template <class T> static bool PutBuffer(const T& str, BytesSink* sink) {
return PutBuffer(str.c_str(), str.size(), sink);
}
,
UPB_DEFINE_STRUCT0(upb_bufsrc,
));
private:
#else
struct upb_bufsrc {
#endif
};
#ifdef __cplusplus
extern "C" {
#endif
UPB_BEGIN_EXTERN_C // {
// Inline definitions.
@ -409,9 +424,7 @@ UPB_INLINE bool upb_sink_endsubmsg(upb_sink *s, upb_selector_t sel) {
return endsubmsg(s->closure, hd);
}
#ifdef __cplusplus
} /* extern "C" */
#endif
UPB_END_EXTERN_C // }
#ifdef __cplusplus

@ -16,27 +16,23 @@
#ifndef UPB_SYMTAB_H_
#define UPB_SYMTAB_H_
#include "upb/def.h"
#ifdef __cplusplus
#include <vector>
namespace upb { class SymbolTable; }
typedef upb::SymbolTable upb_symtab;
#else
struct upb_symtab;
typedef struct upb_symtab upb_symtab;
#endif
#include "upb/def.h"
UPB_DECLARE_TYPE(upb::SymbolTable, upb_symtab);
typedef struct {
UPB_PRIVATE_FOR_CPP
upb_strtable_iter iter;
upb_deftype_t type;
} upb_symtab_iter;
#ifdef __cplusplus
// Non-const methods in upb::SymbolTable are NOT thread-safe.
class upb::SymbolTable {
UPB_DEFINE_CLASS1(upb::SymbolTable, upb::RefCounted,
public:
// Returns a new symbol table with a single ref owned by "owner."
// Returns NULL if memory allocation failed.
@ -124,21 +120,17 @@ class upb::SymbolTable {
private:
UPB_DISALLOW_POD_OPS(SymbolTable, upb::SymbolTable);
#else
struct upb_symtab {
#endif
upb_refcounted base;
,
UPB_DEFINE_STRUCT(upb_symtab, upb_refcounted,
upb_strtable symtab;
};
));
#define UPB_SYMTAB_INIT(symtab, refs, ref2s) \
{ UPB_REFCOUNT_INIT(refs, ref2s), symtab }
UPB_BEGIN_EXTERN_C // {
// Native C API.
#ifdef __cplusplus
extern "C" {
#endif
// From upb_refcounted.
bool upb_symtab_isfrozen(const upb_symtab *s);
void upb_symtab_ref(const upb_symtab *s, const void *owner);
@ -173,32 +165,11 @@ void upb_symtab_next(upb_symtab_iter *iter);
bool upb_symtab_done(const upb_symtab_iter *iter);
const upb_def *upb_symtab_iter_def(const upb_symtab_iter *iter);
#ifdef __cplusplus
} /* extern "C" */
UPB_END_EXTERN_C // }
#ifdef __cplusplus
// C++ inline wrappers.
namespace upb {
template<>
class Pointer<SymbolTable> {
public:
explicit Pointer(SymbolTable* ptr) : ptr_(ptr) {}
operator SymbolTable*() { return ptr_; }
operator RefCounted*() { return UPB_UPCAST(ptr_); }
private:
SymbolTable* ptr_;
};
template<>
class Pointer<const SymbolTable> {
public:
explicit Pointer(const SymbolTable* ptr) : ptr_(ptr) {}
operator const SymbolTable*() { return ptr_; }
operator const RefCounted*() { return UPB_UPCAST(ptr_); }
private:
const SymbolTable* ptr_;
};
inline reffed_ptr<SymbolTable> SymbolTable::New() {
upb_symtab *s = upb_symtab_new(&s);
return reffed_ptr<SymbolTable>(s, &s);

@ -45,7 +45,10 @@
friend class Pointer<full_class_name>; \
friend class Pointer<const full_class_name>; \
UPB_DISALLOW_COPY_AND_ASSIGN(class_name)
#else
#define UPB_ASSERT_STDLAYOUT(type) \
static_assert(std::is_standard_layout<type>::value, \
#type " must be standard layout");
#else // !defined(UPB_CXX11)
#define UPB_DISALLOW_COPY_AND_ASSIGN(class_name) \
class_name(const class_name&); \
void operator=(const class_name&);
@ -56,13 +59,85 @@
friend class Pointer<full_class_name>; \
friend class Pointer<const full_class_name>; \
UPB_DISALLOW_COPY_AND_ASSIGN(class_name)
#define UPB_ASSERT_STDLAYOUT(type)
#endif
#ifdef __cplusplus
#define UPB_PRIVATE_FOR_CPP private:
#else
#define UPB_DECLARE_TYPE(cppname, cname) typedef cppname cname;
#define UPB_BEGIN_EXTERN_C extern "C" {
#define UPB_END_EXTERN_C }
#define UPB_DEFINE_STRUCT0(cname, members) members;
#define UPB_DEFINE_STRUCT(cname, cbase, members) \
public: \
cbase* base() { return &base_; } \
const cbase* base() const { return &base_; } \
\
private: \
cbase base_; \
members;
#define UPB_DEFINE_CLASS0(cppname, cppmethods, members) \
class cppname { \
cppmethods \
members \
}; \
UPB_ASSERT_STDLAYOUT(cppname);
#define UPB_DEFINE_CLASS1(cppname, cppbase, cppmethods, members) \
UPB_DEFINE_CLASS0(cppname, cppmethods, members) \
namespace upb { \
template <> \
class Pointer<cppname> : public PointerBase<cppname, cppbase> { \
public: \
explicit Pointer(cppname* ptr) : PointerBase(ptr) {} \
}; \
template <> \
class Pointer<const cppname> \
: public PointerBase<const cppname, const cppbase> { \
public: \
explicit Pointer(const cppname* ptr) : PointerBase(ptr) {} \
}; \
}
#define UPB_DEFINE_CLASS2(cppname, cppbase, cppbase2, cppmethods, members) \
UPB_DEFINE_CLASS0(cppname, UPB_QUOTE(cppmethods), members) \
namespace upb { \
template <> \
class Pointer<cppname> : public PointerBase2<cppname, cppbase, cppbase2> { \
public: \
explicit Pointer(cppname* ptr) : PointerBase2(ptr) {} \
}; \
template <> \
class Pointer<const cppname> \
: public PointerBase2<const cppname, const cppbase, const cppbase2> { \
public: \
explicit Pointer(const cppname* ptr) : PointerBase2(ptr) {} \
}; \
}
#else // !defined(__cplusplus)
#define UPB_PRIVATE_FOR_CPP
#endif
#define UPB_DECLARE_TYPE(cppname, cname) \
struct cname; \
typedef struct cname cname;
#define UPB_BEGIN_EXTERN_C
#define UPB_END_EXTERN_C
#define UPB_DEFINE_STRUCT0(cname, members) \
struct cname { \
members; \
};
#define UPB_DEFINE_STRUCT(cname, cbase, members) \
struct cname { \
cbase base; \
members; \
};
#define UPB_DEFINE_CLASS0(cppname, cppmethods, members) members
#define UPB_DEFINE_CLASS1(cppname, cppbase, cppmethods, members) members
#define UPB_DEFINE_CLASS2(cppname, cppbase, cppbase2, cppmethods, members) \
members
#endif // defined(__cplusplus)
#ifdef __GNUC__
#define UPB_NORETURN __attribute__((__noreturn__))
@ -75,6 +150,11 @@
#define UPB_UNUSED(var) (void)var
// Code with commas confuses the preprocessor when passed as arguments, whether
// C++ type names with commas (eg. Foo<int, int>) or code blocks that declare
// variables (ie. int foo, bar).
#define UPB_QUOTE(...) __VA_ARGS__
// For asserting something about a variable when the variable is not used for
// anything else. This prevents "unused variable" warnings when compiling in
// debug mode.
@ -118,6 +198,25 @@ template <class T> class Pointer;
// Casts to any base class, or the type itself (ie. can be a no-op).
template <class T> inline Pointer<T> upcast(T *f) { return Pointer<T>(f); }
template <class T, class Base>
class PointerBase {
public:
explicit PointerBase(T* ptr) : ptr_(ptr) {}
operator T*() { return ptr_; }
operator Base*() { return ptr_->base(); }
private:
T* ptr_;
};
template <class T, class Base, class Base2>
class PointerBase2 : public PointerBase<T, Base> {
public:
explicit PointerBase2(T* ptr) : PointerBase<T, Base>(ptr) {}
operator Base2*() { return Pointer<Base>(*this); }
};
}
#endif
@ -230,13 +329,15 @@ template <class T> class reffed_ptr {
/* upb::Status ****************************************************************/
#ifdef __cplusplus
namespace upb { class Status; }
typedef upb::Status upb_status;
#else
struct upb_status;
typedef struct upb_status upb_status;
namespace upb {
class ErrorSpace;
class Status;
}
#endif
UPB_DECLARE_TYPE(upb::ErrorSpace, upb_errorspace);
UPB_DECLARE_TYPE(upb::Status, upb_status);
// The maximum length of an error message before it will get truncated.
#define UPB_STATUS_MAX_MESSAGE 128
@ -245,20 +346,18 @@ typedef struct upb_status upb_status;
// to recover and proceed, but this is not always possible.
typedef bool upb_errcb_t(void *closure, const upb_status* status);
typedef struct {
UPB_DEFINE_CLASS0(upb::ErrorSpace,
,
UPB_DEFINE_STRUCT0(upb_errorspace,
const char *name;
// Should the error message in the status object according to this code.
void (*set_message)(upb_status* status, int code);
} upb_errorspace;
#ifdef __cplusplus
typedef upb_errorspace ErrorSpace;
));
// Object representing a success or failure status.
// It owns no resources and allocates no memory, so it should work
// even in OOM situations.
class upb::Status {
UPB_DEFINE_CLASS0(upb::Status,
public:
Status();
@ -289,9 +388,8 @@ class upb::Status {
private:
UPB_DISALLOW_COPY_AND_ASSIGN(Status);
#else
struct upb_status {
#endif
,
UPB_DEFINE_STRUCT0(upb_status,
bool ok_;
// Specific status code defined by some error space (optional).
@ -300,7 +398,7 @@ struct upb_status {
// Error message; NULL-terminated.
char msg[UPB_STATUS_MAX_MESSAGE];
};
));
#define UPB_STATUS_INIT {true, 0, NULL, {0}}

Loading…
Cancel
Save