WIP.

author: Joshua Haberman <jhaberman@gmail.com> 2019-01-14 10:56:58 -0800
committer: Joshua Haberman <jhaberman@gmail.com> 2019-01-14 10:56:58 -0800
commit: cb26d883d1290ed258e5594454c2ffe0526b13f9 (patch)
tree: 8ca8c172333c159d8bf6c4e315376cdfb2f66882 /upb
parent: a9c375f8ea81e52d832653c963da72033c9a98be (diff)
30 files changed, 511 insertions, 721 deletions
diff --git a/upb/bindings/lua/def.c b/upb/bindings/lua/def.c
index 76510be..c38b6d1 100644
--- a/upb/bindings/lua/def.c
+++ b/upb/bindings/lua/def.c
@@ -15,13 +15,14 @@
 #define LUPB_SYMTAB "lupb.symtab"
 #define LUPB_OBJCACHE "lupb.objcache"
 
-#define CHK(pred) do { \
-    upb_status status = UPB_STATUS_INIT; \
-    pred; \
+#define CHK(pred)                 \
+  do {                            \
+    upb_status status;            \
+    upb_status_clear(&status);    \
+    pred;                         \
     lupb_checkstatus(L, &status); \
   } while (0)
 
-
 /* lupb_wrapper ***************************************************************/
 
 /* Wrappers around upb objects. */
diff --git a/upb/bindings/lua/msg.c b/upb/bindings/lua/msg.c
index e983f46..df5a143 100644
--- a/upb/bindings/lua/msg.c
+++ b/upb/bindings/lua/msg.c
@@ -100,16 +100,21 @@ static void *lupb_newuserdata(lua_State *L, size_t size, const char *type) {
  * it is an internal memory management detail.  Other objects refer to this
  * object from their userdata to keep the arena-owned data alive. */
 
+typedef struct {
+  upb_arena *arena;
+} lupb_arena;
+
 upb_arena *lupb_arena_check(lua_State *L, int narg) {
-  return luaL_checkudata(L, narg, LUPB_ARENA);
+  lupb_arena *a = luaL_checkudata(L, narg, LUPB_ARENA);
+  return a ? a->arena : NULL;
 }
 
 int lupb_arena_new(lua_State *L) {
-  upb_arena *a = lupb_newuserdata(L, sizeof(upb_arena), LUPB_ARENA);
+  lupb_arena *a = lupb_newuserdata(L, sizeof(lupb_arena), LUPB_ARENA);
 
   /* TODO(haberman): use Lua alloc func as block allocator?  Would need to
    * verify that all cases of upb_malloc in msg/table are longjmp-safe. */
-  upb_arena_init(a);
+  a->arena = upb_arena_new();
 
   return 1;
 }
@@ -140,7 +145,7 @@ static void lupb_arena_initsingleton(lua_State *L) {
 
 static int lupb_arena_gc(lua_State *L) {
   upb_arena *a = lupb_arena_check(L, 1);
-  upb_arena_uninit(a);
+  upb_arena_free(a);
   return 0;
 }
 
diff --git a/upb/bindings/lua/upb/pb.c b/upb/bindings/lua/upb/pb.c
index bca2ee8..2edefe0 100644
--- a/upb/bindings/lua/upb/pb.c
+++ b/upb/bindings/lua/upb/pb.c
@@ -27,17 +27,15 @@ static int lupb_pb_decode(lua_State *L) {
 static int lupb_pb_encode(lua_State *L) {
   const upb_msglayout *layout;
   const upb_msg *msg = lupb_msg_checkmsg2(L, 1, &layout);
-  upb_arena arena;
+  upb_arena *arena = upb_arena_new();
   size_t size;
   char *result;
 
-  upb_arena_init(&arena);
-
-  result = upb_encode(msg, (const void*)layout, &arena, &size);
+  result = upb_encode(msg, (const void*)layout, arena, &size);
 
   /* Free resources before we potentially bail on error. */
   lua_pushlstring(L, result, size);
-  upb_arena_uninit(&arena);
+  upb_arena_free(arena);
   /* TODO(haberman): check for error. */
 
   return 1;
diff --git a/upb/decode.h b/upb/decode.h
index 79774ed..790d7ef 100644
--- a/upb/decode.h
+++ b/upb/decode.h
@@ -7,10 +7,14 @@
 
 #include "upb/msg.h"
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 bool upb_decode(upb_stringview buf, upb_msg *msg, const upb_msglayout *l);
 
-UPB_END_EXTERN_C
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #endif  /* UPB_DECODE_H_ */
diff --git a/upb/def.c b/upb/def.c
index 27de875..c744138 100644
--- a/upb/def.c
+++ b/upb/def.c
@@ -125,7 +125,7 @@ static upb_value pack_def(const void *ptr, upb_deftype_t type) {
 }
 
 struct upb_symtab {
-  upb_arena arena;
+  upb_arena *arena;
   upb_strtable syms;  /* full_name -> packed def ptr */
   upb_strtable files;  /* file_name -> upb_filedef* */
 };
@@ -224,7 +224,7 @@ static bool assign_msg_indices(upb_msgdef *m, upb_status *s) {
 
   fields = upb_gmalloc(n * sizeof(*fields));
   if (!fields) {
-    upb_upberr_setoom(s);
+    upb_status_setoom(s);
     return false;
   }
 
@@ -870,7 +870,7 @@ const upb_enumdef *upb_filedef_enum(const upb_filedef *f, int i) {
 }
 
 void upb_symtab_free(upb_symtab *s) {
-  upb_arena_uninit(&s->arena);
+  upb_arena_free(s->arena);
   upb_gfree(s);
 }
 
@@ -882,12 +882,12 @@ upb_symtab *upb_symtab_new() {
     return NULL;
   }
 
-  upb_arena_init(&s->arena);
-  alloc = upb_arena_alloc(&s->arena);
+  s->arena = upb_arena_new();
+  alloc = upb_arena_alloc(s->arena);
 
   if (!upb_strtable_init2(&s->syms, UPB_CTYPE_CONSTPTR, alloc) ||
       !upb_strtable_init2(&s->files, UPB_CTYPE_CONSTPTR, alloc)) {
-    upb_arena_uninit(&s->arena);
+    upb_arena_free(s->arena);
     upb_gfree(s);
     s = NULL;
   }
@@ -922,7 +922,7 @@ const upb_enumdef *upb_symtab_lookupenum(const upb_symtab *s, const char *sym) {
  * to validate important constraints like uniqueness of names and numbers. */
 
 #define CHK(x) if (!(x)) { return false; }
-#define CHK_OOM(x) if (!(x)) { upb_upberr_setoom(ctx->status); return false; }
+#define CHK_OOM(x) if (!(x)) { upb_status_setoom(ctx->status); return false; }
 
 typedef struct {
   const upb_symtab *symtab;
@@ -1632,7 +1632,7 @@ static bool build_filedef(
 static bool upb_symtab_addtotabs(upb_symtab *s, symtab_addctx *ctx,
                                  upb_status *status) {
   const upb_filedef *file = ctx->file;
-  upb_alloc *alloc = upb_arena_alloc(&s->arena);
+  upb_alloc *alloc = upb_arena_alloc(s->arena);
   upb_strtable_iter iter;
 
   CHK_OOM(upb_strtable_insert3(&s->files, file->name, strlen(file->name),
@@ -1652,9 +1652,9 @@ static bool upb_symtab_addtotabs(upb_symtab *s, symtab_addctx *ctx,
 bool upb_symtab_addfile(upb_symtab *s,
                         const google_protobuf_FileDescriptorProto *file_proto,
                         upb_status *status) {
-  upb_arena tmparena;
+  upb_arena *tmparena = upb_arena_new();
   upb_strtable addtab;
-  upb_alloc *alloc = upb_arena_alloc(&s->arena);
+  upb_alloc *alloc = upb_arena_alloc(s->arena);
   upb_filedef *file = upb_malloc(alloc, sizeof(*file));
   bool ok;
   symtab_addctx ctx;
@@ -1662,18 +1662,16 @@ bool upb_symtab_addfile(upb_symtab *s,
   ctx.file = file;
   ctx.symtab = s;
   ctx.alloc = alloc;
-  ctx.tmp = upb_arena_alloc(&tmparena);
+  ctx.tmp = upb_arena_alloc(tmparena);
   ctx.addtab = &addtab;
   ctx.status = status;
 
-  upb_arena_init(&tmparena);
-
   ok = file &&
       upb_strtable_init2(&addtab, UPB_CTYPE_CONSTPTR, ctx.tmp) &&
       build_filedef(&ctx, file, file_proto) &&
       upb_symtab_addtotabs(s, &ctx, status);
 
-  upb_arena_uninit(&tmparena);
+  upb_arena_free(tmparena);
   return ok;
 }
 
@@ -1685,19 +1683,22 @@ bool _upb_symtab_loaddefinit(upb_symtab *s, const upb_def_init *init) {
    * print errors to stderr instead of returning error status to the user. */
   upb_def_init **deps = init->deps;
   google_protobuf_FileDescriptorProto *file;
-  upb_arena arena;
-  upb_status status = UPB_STATUS_INIT;
+  upb_arena *arena;
+  upb_status status;
+
+  upb_status_clear(&status);
 
   if (upb_strtable_lookup(&s->files, init->filename, NULL)) {
     return true;
   }
 
+  arena = upb_arena_new();
+
   for (; *deps; deps++) {
     if (!_upb_symtab_loaddefinit(s, *deps)) goto err;
   }
 
-  upb_arena_init(&arena);
-  file = google_protobuf_FileDescriptorProto_parsenew(init->descriptor, &arena);
+  file = google_protobuf_FileDescriptorProto_parsenew(init->descriptor, arena);
 
   if (!file) {
     upb_status_seterrf(
@@ -1710,13 +1711,13 @@ bool _upb_symtab_loaddefinit(upb_symtab *s, const upb_def_init *init) {
 
   if (!upb_symtab_addfile(s, file, &status)) goto err;
 
-  upb_arena_uninit(&arena);
+  upb_arena_free(arena);
   return true;
 
 err:
   fprintf(stderr, "Error loading compiled-in descriptor: %s\n",
           upb_status_errmsg(&status));
-  upb_arena_uninit(&arena);
+  upb_arena_free(arena);
   return false;
 }
 
diff --git a/upb/def.h b/upb/def.h
index fb8a71d..b1cf275 100644
--- a/upb/def.h
+++ b/upb/def.h
@@ -56,7 +56,9 @@ typedef struct upb_symtab upb_symtab;
  * protobuf wire format. */
 #define UPB_MAX_FIELDNUMBER ((1 << 29) - 1)
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 const char *upb_fielddef_fullname(const upb_fielddef *f);
 upb_fieldtype_t upb_fielddef_type(const upb_fielddef *f);
@@ -93,9 +95,8 @@ const upb_enumdef *upb_fielddef_enumsubdef(const upb_fielddef *f);
 /* Internal only. */
 uint32_t upb_fielddef_selectorbase(const upb_fielddef *f);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* 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
@@ -228,7 +229,9 @@ class upb::FieldDefPtr {
 
 /* upb_oneofdef ***************************************************************/
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 typedef upb_inttable_iter upb_oneof_iter;
 
@@ -262,9 +265,8 @@ void upb_oneof_iter_setdone(upb_oneof_iter *iter);
 bool upb_oneof_iter_isequal(const upb_oneof_iter *iter1,
                             const upb_oneof_iter *iter2);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Class that represents a oneof. */
 class upb::OneofDefPtr {
@@ -365,7 +367,9 @@ typedef upb_strtable_iter upb_msg_oneof_iter;
 #define UPB_TIMESTAMP_SECONDS 1
 #define UPB_TIMESTAMP_NANOS 2
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 const char *upb_msgdef_fullname(const upb_msgdef *m);
 const upb_filedef *upb_msgdef_file(const upb_msgdef *m);
@@ -441,9 +445,8 @@ void upb_msg_oneof_iter_setdone(upb_msg_oneof_iter * iter);
 bool upb_msg_oneof_iter_isequal(const upb_msg_oneof_iter *iter1,
                                 const upb_msg_oneof_iter *iter2);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Structure that describes a single .proto message type. */
 class upb::MessageDefPtr {
@@ -711,7 +714,9 @@ class upb::EnumDefPtr {
 
 /* upb_filedef ****************************************************************/
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 const char *upb_filedef_name(const upb_filedef *f);
 const char *upb_filedef_package(const upb_filedef *f);
@@ -725,9 +730,8 @@ const upb_filedef *upb_filedef_dep(const upb_filedef *f, int i);
 const upb_msgdef *upb_filedef_msg(const upb_filedef *f, int i);
 const upb_enumdef *upb_filedef_enum(const upb_filedef *f, int i);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Class that represents a .proto file with some things defined in it.
  *
@@ -773,7 +777,9 @@ class upb::FileDefPtr {
 
 /* upb_symtab *****************************************************************/
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 upb_symtab *upb_symtab_new();
 void upb_symtab_free(upb_symtab* s);
@@ -795,9 +801,8 @@ typedef struct upb_def_init {
 
 bool _upb_symtab_loaddefinit(upb_symtab *s, const upb_def_init *init);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Non-const methods in upb::SymbolTable are NOT thread-safe. */
 class upb::SymbolTable {
@@ -823,7 +828,7 @@ class upb::SymbolTable {
   /* Adds the given serialized FileDescriptorProto to the pool. */
   bool AddFile(const google_protobuf_FileDescriptorProto *file_proto,
                Status *status) {
-    return upb_symtab_addfile(ptr_.get(), file_proto, status);
+    return upb_symtab_addfile(ptr_.get(), file_proto, status->ptr());
   }
 
  private:
diff --git a/upb/encode.h b/upb/encode.h
index 1a451b0..6842777 100644
--- a/upb/encode.h
+++ b/upb/encode.h
@@ -7,11 +7,15 @@
 
 #include "upb/msg.h"
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 char *upb_encode(const void *msg, const upb_msglayout *l, upb_arena *arena,
                  size_t *size);
 
-UPB_END_EXTERN_C
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #endif  /* UPB_ENCODE_H_ */
diff --git a/upb/generated_util.h b/upb/generated_util.h
index 3989f1e..657280f 100644
--- a/upb/generated_util.h
+++ b/upb/generated_util.h
@@ -54,10 +54,9 @@ UPB_INLINE void *_upb_array_resize_accessor(void *msg, size_t ofs, size_t size,
     size_t new_size = UPB_MAX(arr->size, 4);
     size_t old_bytes = arr->size * elem_size;
     size_t new_bytes;
-    upb_alloc *alloc = upb_arena_alloc(arr->arena);
     while (new_size < size) new_size *= 2;
     new_bytes = new_size * elem_size;
-    arr->data = upb_realloc(alloc, arr->data, old_bytes, new_bytes);
+    arr->data = upb_arena_realloc(arena, arr->data, old_bytes, new_bytes);
     if (!arr->data) {
       return NULL;
     }
diff --git a/upb/handlers.c b/upb/handlers.c
index ca978bf..aa23b46 100644
--- a/upb/handlers.c
+++ b/upb/handlers.c
@@ -390,7 +390,7 @@ uint32_t upb_handlers_selectorcount(const upb_fielddef *f) {
 /* upb_handlercache ***********************************************************/
 
 struct upb_handlercache {
-  upb_arena arena;
+  upb_arena *arena;
   upb_inttable tab;  /* maps upb_msgdef* -> upb_handlers*. */
   upb_inttable cleanup_;
   upb_handlers_callback *callback;
@@ -407,7 +407,7 @@ const upb_handlers *upb_handlercache_get(upb_handlercache *c,
     return upb_value_getptr(v);
   }
 
-  h = upb_handlers_new(md, c, &c->arena);
+  h = upb_handlers_new(md, c, c->arena);
   v = upb_value_ptr(h);
 
   if (!h) return NULL;
@@ -442,7 +442,7 @@ upb_handlercache *upb_handlercache_new(upb_handlers_callback *callback,
 
   if (!cache) return NULL;
 
-  upb_arena_init(&cache->arena);
+  cache->arena = upb_arena_new();
 
   cache->callback = callback;
   cache->closure = closure;
@@ -470,7 +470,7 @@ void upb_handlercache_free(upb_handlercache *cache) {
 
   upb_inttable_uninit(&cache->tab);
   upb_inttable_uninit(&cache->cleanup_);
-  upb_arena_uninit(&cache->arena);
+  upb_arena_free(cache->arena);
   upb_gfree(cache);
 }
 
diff --git a/upb/handlers.h b/upb/handlers.h
index 44cad18..764e83e 100644
--- a/upb/handlers.h
+++ b/upb/handlers.h
@@ -157,7 +157,9 @@ typedef size_t upb_string_handlerfunc(void *c, const void *hd, const char *buf,
 struct upb_handlers;
 typedef struct upb_handlers upb_handlers;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /* Mutating accessors. */
 const upb_status *upb_handlers_status(upb_handlers *h);
@@ -235,9 +237,8 @@ UPB_INLINE upb_selector_t upb_handlers_getendselector(upb_selector_t start) {
 uint32_t upb_handlers_selectorbaseoffset(const upb_fielddef *f);
 uint32_t upb_handlers_selectorcount(const upb_fielddef *f);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 namespace upb {
 typedef upb_handlers Handlers;
@@ -303,7 +304,9 @@ template <class T> class upb::Handler {
   const upb_handlerattr& attr() const { return attr_; }
 
  private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Handler)
+  Handler(const Handler&) = delete;
+  Handler& operator=(const Handler&) = delete;
+
   FuncPtr handler_;
   mutable upb_handlerattr attr_;
   mutable bool registered_;
@@ -334,7 +337,8 @@ class upb::HandlersPtr {
   typedef Handler<void *(*)(void *, const void *)> StartFieldHandler;
   typedef Handler<bool (*)(void *, const void *)> EndFieldHandler;
   typedef Handler<bool (*)(void *, const void *)> StartMessageHandler;
-  typedef Handler<bool (*)(void *, const void *, Status *)> EndMessageHandler;
+  typedef Handler<bool (*)(void *, const void *, upb_status *)>
+      EndMessageHandler;
   typedef Handler<void *(*)(void *, const void *, size_t)> StartStringHandler;
   typedef Handler<size_t (*)(void *, const void *, const char *, size_t,
                              const upb_bufhandle *)>
@@ -590,7 +594,9 @@ class upb::HandlersPtr {
 
 /* upb_handlercache ***********************************************************/
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 struct upb_handlercache;
 typedef struct upb_handlercache upb_handlercache;
@@ -605,9 +611,8 @@ const upb_handlers *upb_handlercache_get(upb_handlercache *cache,
 bool upb_handlercache_addcleanup(upb_handlercache *h, void *p,
                                  upb_handlerfree *hfree);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 class upb::HandlerCache {
  public:
@@ -631,8 +636,6 @@ class upb::HandlerCache {
 
 /* upb_byteshandler ***********************************************************/
 
-UPB_BEGIN_EXTERN_C
-
 typedef struct {
   upb_func *func;
 
@@ -665,6 +668,10 @@ UPB_INLINE void upb_byteshandler_init(upb_byteshandler *handler) {
   *handler = init;
 }
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Caller must ensure that "d" outlives the handlers. */
 bool upb_byteshandler_setstartstr(upb_byteshandler *h,
                                   upb_startstr_handlerfunc *func, void *d);
@@ -674,16 +681,18 @@ bool upb_byteshandler_setendstr(upb_byteshandler *h,
                                 upb_endfield_handlerfunc *func, void *d);
 
 #ifdef __cplusplus
+}  /* extern "C" */
+
 namespace upb {
 typedef upb_byteshandler BytesHandler;
 }
 #endif
 
-UPB_END_EXTERN_C
-
 /** Message handlers ******************************************************************/
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /* These are the handlers used internally by upb_msgfactory_getmergehandlers().
  * They write scalar data to a known offset from the message pointer.
@@ -710,7 +719,9 @@ bool upb_msg_getscalarhandlerdata(const upb_handlers *h,
 
 
 
-UPB_END_EXTERN_C
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #include "upb/handlers-inl.h"
 
diff --git a/upb/json/parser.c b/upb/json/parser.c
index 1dac800..a594bfd 100644
--- a/upb/json/parser.c
+++ b/upb/json/parser.c
@@ -212,7 +212,7 @@ typedef struct {
 } upb_jsonparser_frame;
 
 struct upb_json_parser {
-  upb_env *env;
+  upb_arena *arena;
   const upb_json_parsermethod *method;
   upb_bytessink input_;
 
@@ -221,7 +221,7 @@ struct upb_json_parser {
   upb_jsonparser_frame *top;
   upb_jsonparser_frame *limit;
 
-  upb_status status;
+  upb_status *status;
 
   /* Ragel's internal parsing stack for the parsing state machine. */
   int current_state;
@@ -259,7 +259,7 @@ struct upb_json_parser {
 };
 
 struct upb_json_codecache {
-  upb_arena arena;
+  upb_arena *arena;
   upb_inttable methods;   /* upb_msgdef* -> upb_json_parsermethod* */
 };
 
@@ -277,7 +277,7 @@ static upb_jsonparser_any_frame *json_parser_any_frame_new(
     upb_json_parser *p) {
   upb_jsonparser_any_frame *frame;
 
-  frame = upb_env_malloc(p->env, sizeof(upb_jsonparser_any_frame));
+  frame = upb_arena_malloc(p->arena, sizeof(upb_jsonparser_any_frame));
 
   frame->encoder_handlercache = upb_pb_encoder_newcache();
   frame->parser_codecache = upb_json_codecache_new();
@@ -301,12 +301,12 @@ static void json_parser_any_frame_set_payload_type(
 
   /* Initialize encoder. */
   h = upb_handlercache_get(frame->encoder_handlercache, payload_type);
-  encoder = upb_pb_encoder_create(p->env, h, frame->stringsink.sink);
+  encoder = upb_pb_encoder_create(p->arena, h, frame->stringsink.sink);
 
   /* Initialize parser. */
   parser_method = upb_json_codecache_get(frame->parser_codecache, payload_type);
   upb_sink_reset(&frame->sink, h, encoder);
-  frame->parser = upb_json_parser_create(p->env, parser_method, p->symtab,
+  frame->parser = upb_json_parser_create(p->arena, parser_method, p->symtab,
                                          frame->sink, p->ignore_json_unknown);
 }
 
@@ -372,8 +372,7 @@ static upb_selector_t parser_getsel(upb_json_parser *p) {
 
 static bool check_stack(upb_json_parser *p) {
   if ((p->top + 1) == p->limit) {
-    upb_status_seterrmsg(&p->status, "Nesting too deep");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Nesting too deep");
     return false;
   }
 
@@ -468,10 +467,9 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
     char output[3];
 
     if (limit - ptr < 4) {
-      upb_status_seterrf(&p->status,
+      upb_status_seterrf(p->status,
                          "Base64 input for bytes field not a multiple of 4: %s",
                          upb_fielddef_name(p->top->f));
-      upb_env_reporterror(p->env, &p->status);
       return false;
     }
 
@@ -495,10 +493,9 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
 otherchar:
   if (nonbase64(ptr[0]) || nonbase64(ptr[1]) || nonbase64(ptr[2]) ||
       nonbase64(ptr[3]) ) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Non-base64 characters in bytes field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   } if (ptr[2] == '=') {
     uint32_t val;
@@ -536,11 +533,10 @@ otherchar:
   }
 
 badpadding:
-  upb_status_seterrf(&p->status,
+  upb_status_seterrf(p->status,
                      "Incorrect base64 padding for field: %s (%.*s)",
                      upb_fielddef_name(p->top->f),
                      4, ptr);
-  upb_env_reporterror(p->env, &p->status);
   return false;
 }
 
@@ -584,10 +580,9 @@ static bool accumulate_realloc(upb_json_parser *p, size_t need) {
     new_size = saturating_multiply(new_size, 2);
   }
 
-  mem = upb_env_realloc(p->env, p->accumulate_buf, old_size, new_size);
+  mem = upb_arena_realloc(p->arena, p->accumulate_buf, old_size, new_size);
   if (!mem) {
-    upb_status_seterrmsg(&p->status, "Out of memory allocating buffer.");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Out of memory allocating buffer.");
     return false;
   }
 
@@ -610,8 +605,7 @@ static bool accumulate_append(upb_json_parser *p, const char *buf, size_t len,
   }
 
   if (!checked_add(p->accumulated_len, len, &need)) {
-    upb_status_seterrmsg(&p->status, "Integer overflow.");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Integer overflow.");
     return false;
   }
 
@@ -689,8 +683,7 @@ static bool multipart_text(upb_json_parser *p, const char *buf, size_t len,
   switch (p->multipart_state) {
     case MULTIPART_INACTIVE:
       upb_status_seterrmsg(
-          &p->status, "Internal error: unexpected state MULTIPART_INACTIVE");
-      upb_env_reporterror(p->env, &p->status);
+          p->status, "Internal error: unexpected state MULTIPART_INACTIVE");
       return false;
 
     case MULTIPART_ACCUMULATE:
@@ -1055,8 +1048,7 @@ static bool parse_number(upb_json_parser *p, bool is_quoted) {
     multipart_end(p);
     return true;
   } else {
-    upb_status_seterrf(&p->status, "error parsing number: %s", buf);
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrf(p->status, "error parsing number: %s", buf);
     multipart_end(p);
     return false;
   }
@@ -1070,10 +1062,9 @@ static bool parser_putbool(upb_json_parser *p, bool val) {
   }
 
   if (upb_fielddef_type(p->top->f) != UPB_TYPE_BOOL) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Boolean value specified for non-bool field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1248,10 +1239,9 @@ static bool start_stringval(upb_json_parser *p) {
     multipart_startaccum(p);
     return true;
   } else {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "String specified for bool or submessage field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 }
@@ -1284,8 +1274,7 @@ static bool end_any_stringval(upb_json_parser *p) {
     payload_type = upb_symtab_lookupmsg2(p->symtab, buf, len);
     if (payload_type == NULL) {
       upb_status_seterrf(
-          &p->status, "Cannot find packed type: %.*s\n", (int)len, buf);
-      upb_env_reporterror(p->env, &p->status);
+          p->status, "Cannot find packed type: %.*s\n", (int)len, buf);
       return false;
     }
 
@@ -1294,8 +1283,7 @@ static bool end_any_stringval(upb_json_parser *p) {
     return true;
   } else {
     upb_status_seterrf(
-        &p->status, "Invalid type url: %.*s\n", (int)len, buf);
-    upb_env_reporterror(p->env, &p->status);
+        p->status, "Invalid type url: %.*s\n", (int)len, buf);
     return false;
   }
 }
@@ -1347,8 +1335,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
         upb_selector_t sel = parser_getsel(p);
         upb_sink_putint32(&p->top->sink, sel, int_val);
       } else {
-        upb_status_seterrf(&p->status, "Enum value unknown: '%.*s'", len, buf);
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrf(p->status, "Enum value unknown: '%.*s'", len, buf);
       }
 
       break;
@@ -1365,8 +1352,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
 
     default:
       UPB_ASSERT(false);
-      upb_status_seterrmsg(&p->status, "Internal error in JSON decoder");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrmsg(p->status, "Internal error in JSON decoder");
       ok = false;
       break;
   }
@@ -1445,25 +1431,22 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   memcpy(seconds_buf, buf, fraction_start);
   seconds = strtol(seconds_buf, &end, 10);
   if (errno == ERANGE || end != seconds_buf + fraction_start) {
-    upb_status_seterrf(&p->status, "error parsing duration: %s",
+    upb_status_seterrf(p->status, "error parsing duration: %s",
                        seconds_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
   if (seconds > 315576000000) {
-    upb_status_seterrf(&p->status, "error parsing duration: "
+    upb_status_seterrf(p->status, "error parsing duration: "
                                    "maximum acceptable value is "
                                    "315576000000");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
   if (seconds < -315576000000) {
-    upb_status_seterrf(&p->status, "error parsing duration: "
+    upb_status_seterrf(p->status, "error parsing duration: "
                                    "minimum acceptable value is "
                                    "-315576000000");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1472,9 +1455,8 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   memcpy(nanos_buf + 1, buf + fraction_start, len - fraction_start);
   val = strtod(nanos_buf, &end);
   if (errno == ERANGE || end != nanos_buf + len - fraction_start + 1) {
-    upb_status_seterrf(&p->status, "error parsing duration: %s",
+    upb_status_seterrf(p->status, "error parsing duration: %s",
                        nanos_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1500,7 +1482,7 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
   end_member(p);
 
-  /* Continue previous environment */
+  /* Continue previous arena */
   multipart_startaccum(p);
 
   return true;
@@ -1530,8 +1512,7 @@ static bool end_timestamp_base(upb_json_parser *p, const char *ptr) {
 
   /* Parse seconds */
   if (strptime(timestamp_buf, "%FT%H:%M:%S%Z", &p->tm) == NULL) {
-    upb_status_seterrf(&p->status, "error parsing timestamp: %s", buf);
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrf(p->status, "error parsing timestamp: %s", buf);
     return false;
   }
 
@@ -1564,9 +1545,8 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   buf = accumulate_getptr(p, &len);
 
   if (len > 10) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
         "error parsing timestamp: at most 9-digit fraction.");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1576,9 +1556,8 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   val = strtod(nanos_buf, &end);
 
   if (errno == ERANGE || end != nanos_buf + len + 1) {
-    upb_status_seterrf(&p->status, "error parsing timestamp nanos: %s",
+    upb_status_seterrf(p->status, "error parsing timestamp nanos: %s",
                        nanos_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1620,8 +1599,7 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
 
   if (buf[0] != 'Z') {
     if (sscanf(buf + 1, "%2d:00", &hours) != 1) {
-      upb_status_seterrf(&p->status, "error parsing timestamp offset");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrf(p->status, "error parsing timestamp offset");
       return false;
     }
 
@@ -1637,10 +1615,9 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
 
   /* Check timestamp boundary */
   if (seconds < -62135596800) {
-    upb_status_seterrf(&p->status, "error parsing timestamp: "
+    upb_status_seterrf(p->status, "error parsing timestamp: "
                                    "minimum acceptable value is "
                                    "0001-01-01T00:00:00Z");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1681,8 +1658,7 @@ static bool parse_mapentry_key(upb_json_parser *p) {
 
   p->top->f = upb_msgdef_itof(p->top->m, UPB_MAPENTRY_KEY);
   if (p->top->f == NULL) {
-    upb_status_seterrmsg(&p->status, "mapentry message has no key");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "mapentry message has no key");
     return false;
   }
   switch (upb_fielddef_type(p->top->f)) {
@@ -1705,9 +1681,8 @@ static bool parse_mapentry_key(upb_json_parser *p) {
           return false;
         }
       } else {
-        upb_status_seterrmsg(&p->status,
+        upb_status_seterrmsg(p->status,
                              "Map bool key not 'true' or 'false'");
-        upb_env_reporterror(p->env, &p->status);
         return false;
       }
       multipart_end(p);
@@ -1725,8 +1700,7 @@ static bool parse_mapentry_key(upb_json_parser *p) {
       break;
     }
     default:
-      upb_status_seterrmsg(&p->status, "Invalid field type for map key");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrmsg(p->status, "Invalid field type for map key");
       return false;
   }
 
@@ -1785,8 +1759,7 @@ static bool handle_mapentry(upb_json_parser *p) {
   p->top->is_mapentry = true;  /* set up to pop frame after value is parsed. */
   p->top->mapfield = mapfield;
   if (p->top->f == NULL) {
-    upb_status_seterrmsg(&p->status, "mapentry message has no value");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "mapentry message has no value");
     return false;
   }
 
@@ -1821,8 +1794,7 @@ static bool end_membername(upb_json_parser *p) {
       multipart_end(p);
       return true;
     } else {
-      upb_status_seterrf(&p->status, "No such field: %.*s\n", (int)len, buf);
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrf(p->status, "No such field: %.*s\n", (int)len, buf);
       return false;
     }
   }
@@ -1848,14 +1820,13 @@ static bool end_any_membername(upb_json_parser *p) {
 static void end_member(upb_json_parser *p) {
   /* If we just parsed a map-entry value, end that frame too. */
   if (p->top->is_mapentry) {
-    upb_status s = UPB_STATUS_INIT;
     upb_selector_t sel;
     bool ok;
     const upb_fielddef *mapfield;
 
     UPB_ASSERT(p->top > p->stack);
     /* send ENDMSG on submsg. */
-    upb_sink_endmsg(&p->top->sink, &s);
+    upb_sink_endmsg(&p->top->sink, p->status);
     mapfield = p->top->mapfield;
 
     /* send ENDSUBMSG in repeated-field-of-mapentries frame. */
@@ -1949,10 +1920,9 @@ static bool start_subobject(upb_json_parser *p) {
 
     return true;
   } else {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Object specified for non-message/group field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 }
@@ -2060,10 +2030,9 @@ static bool start_array(upb_json_parser *p) {
   }
 
   if (!upb_fielddef_isseq(p->top->f)) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Array specified for non-repeated field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -2122,12 +2091,7 @@ static void start_object(upb_json_parser *p) {
 
 static void end_object(upb_json_parser *p) {
   if (!p->top->is_map && p->top->m != NULL) {
-    upb_status status;
-    upb_status_clear(&status);
-    upb_sink_endmsg(&p->top->sink, &status);
-    if (!upb_ok(&status)) {
-      upb_env_reporterror(p->env, &status);
-    }
+    upb_sink_endmsg(&p->top->sink, p->status);
   }
 }
 
@@ -2146,8 +2110,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
 
   if (json_parser_any_frame_has_value(p->top->any_frame) &&
       !json_parser_any_frame_has_type_url(p->top->any_frame)) {
-    upb_status_seterrmsg(&p->status, "No valid type url");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "No valid type url");
     return false;
   }
 
@@ -2162,8 +2125,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
                  p->top->any_frame->before_type_url_end -
                  p->top->any_frame->before_type_url_start);
       if (p->top->any_frame->before_type_url_start == NULL) {
-        upb_status_seterrmsg(&p->status, "invalid data for well known type.");
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrmsg(p->status, "invalid data for well known type.");
         return false;
       }
       p->top->any_frame->before_type_url_start++;
@@ -2175,8 +2137,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
                  (ptr + 1) -
                  p->top->any_frame->after_type_url_start);
       if (p->top->any_frame->after_type_url_start == NULL) {
-        upb_status_seterrmsg(&p->status, "Invalid data for well known type.");
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrmsg(p->status, "Invalid data for well known type.");
         return false;
       }
       p->top->any_frame->after_type_url_start++;
@@ -2249,7 +2210,6 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
 
   /* Deallocate any parse frame. */
   json_parser_any_frame_free(p->top->any_frame);
-  upb_env_free(p->env, p->top->any_frame);
 
   return true;
 }
@@ -2419,11 +2379,11 @@ static bool is_string_wrapper_object(upb_json_parser *p) {
  * final state once, when the closing '"' is seen. */
 
 
-#line 2581 "upb/json/parser.rl"
+#line 2541 "upb/json/parser.rl"
 
 
 
-#line 2427 "upb/json/parser.c"
+#line 2387 "upb/json/parser.c"
 static const char _json_actions[] = {
 	0, 1, 0, 1, 1, 1, 3, 1, 
 	4, 1, 6, 1, 7, 1, 8, 1, 
@@ -2670,7 +2630,7 @@ static const int json_en_value_machine = 75;
 static const int json_en_main = 1;
 
 
-#line 2584 "upb/json/parser.rl"
+#line 2544 "upb/json/parser.rl"
 
 size_t parse(void *closure, const void *hd, const char *buf, size_t size,
              const upb_bufhandle *handle) {
@@ -2693,7 +2653,7 @@ size_t parse(void *closure, const void *hd, const char *buf, size_t size,
   capture_resume(parser, buf);
 
   
-#line 2697 "upb/json/parser.c"
+#line 2657 "upb/json/parser.c"
 	{
 	int _klen;
 	unsigned int _trans;
@@ -2768,83 +2728,83 @@ _match:
 		switch ( *_acts++ )
 		{
 	case 1:
-#line 2432 "upb/json/parser.rl"
+#line 2392 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 2:
-#line 2434 "upb/json/parser.rl"
+#line 2394 "upb/json/parser.rl"
 	{ p--; {stack[top++] = cs; cs = 23;goto _again;} }
 	break;
 	case 3:
-#line 2438 "upb/json/parser.rl"
+#line 2398 "upb/json/parser.rl"
 	{ start_text(parser, p); }
 	break;
 	case 4:
-#line 2439 "upb/json/parser.rl"
+#line 2399 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_text(parser, p)); }
 	break;
 	case 5:
-#line 2445 "upb/json/parser.rl"
+#line 2405 "upb/json/parser.rl"
 	{ start_hex(parser); }
 	break;
 	case 6:
-#line 2446 "upb/json/parser.rl"
+#line 2406 "upb/json/parser.rl"
 	{ hexdigit(parser, p); }
 	break;
 	case 7:
-#line 2447 "upb/json/parser.rl"
+#line 2407 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_hex(parser)); }
 	break;
 	case 8:
-#line 2453 "upb/json/parser.rl"
+#line 2413 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(escape(parser, p)); }
 	break;
 	case 9:
-#line 2459 "upb/json/parser.rl"
+#line 2419 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 10:
-#line 2471 "upb/json/parser.rl"
+#line 2431 "upb/json/parser.rl"
 	{ start_duration_base(parser, p); }
 	break;
 	case 11:
-#line 2472 "upb/json/parser.rl"
+#line 2432 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_duration_base(parser, p)); }
 	break;
 	case 12:
-#line 2474 "upb/json/parser.rl"
+#line 2434 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 13:
-#line 2479 "upb/json/parser.rl"
+#line 2439 "upb/json/parser.rl"
 	{ start_timestamp_base(parser, p); }
 	break;
 	case 14:
-#line 2480 "upb/json/parser.rl"
+#line 2440 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_timestamp_base(parser, p)); }
 	break;
 	case 15:
-#line 2482 "upb/json/parser.rl"
+#line 2442 "upb/json/parser.rl"
 	{ start_timestamp_fraction(parser, p); }
 	break;
 	case 16:
-#line 2483 "upb/json/parser.rl"
+#line 2443 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_timestamp_fraction(parser, p)); }
 	break;
 	case 17:
-#line 2485 "upb/json/parser.rl"
+#line 2445 "upb/json/parser.rl"
 	{ start_timestamp_zone(parser, p); }
 	break;
 	case 18:
-#line 2486 "upb/json/parser.rl"
+#line 2446 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_timestamp_zone(parser, p)); }
 	break;
 	case 19:
-#line 2488 "upb/json/parser.rl"
+#line 2448 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 20:
-#line 2493 "upb/json/parser.rl"
+#line 2453 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_TIMESTAMP)) {
           {stack[top++] = cs; cs = 47;goto _again;}
@@ -2856,11 +2816,11 @@ _match:
       }
 	break;
 	case 21:
-#line 2504 "upb/json/parser.rl"
+#line 2464 "upb/json/parser.rl"
 	{ p--; {stack[top++] = cs; cs = 75;goto _again;} }
 	break;
 	case 22:
-#line 2509 "upb/json/parser.rl"
+#line 2469 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           start_any_member(parser, p);
@@ -2870,11 +2830,11 @@ _match:
       }
 	break;
 	case 23:
-#line 2516 "upb/json/parser.rl"
+#line 2476 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_membername(parser)); }
 	break;
 	case 24:
-#line 2519 "upb/json/parser.rl"
+#line 2479 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           end_any_member(parser, p);
@@ -2884,7 +2844,7 @@ _match:
       }
 	break;
 	case 25:
-#line 2530 "upb/json/parser.rl"
+#line 2490 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           start_any_object(parser, p);
@@ -2894,7 +2854,7 @@ _match:
       }
 	break;
 	case 26:
-#line 2539 "upb/json/parser.rl"
+#line 2499 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           CHECK_RETURN_TOP(end_any_object(parser, p));
@@ -2904,54 +2864,54 @@ _match:
       }
 	break;
 	case 27:
-#line 2551 "upb/json/parser.rl"
+#line 2511 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_array(parser)); }
 	break;
 	case 28:
-#line 2555 "upb/json/parser.rl"
+#line 2515 "upb/json/parser.rl"
 	{ end_array(parser); }
 	break;
 	case 29:
-#line 2560 "upb/json/parser.rl"
+#line 2520 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_number(parser, p)); }
 	break;
 	case 30:
-#line 2561 "upb/json/parser.rl"
+#line 2521 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_number(parser, p)); }
 	break;
 	case 31:
-#line 2563 "upb/json/parser.rl"
+#line 2523 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_stringval(parser)); }
 	break;
 	case 32:
-#line 2564 "upb/json/parser.rl"
+#line 2524 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_stringval(parser)); }
 	break;
 	case 33:
-#line 2566 "upb/json/parser.rl"
+#line 2526 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, true)); }
 	break;
 	case 34:
-#line 2568 "upb/json/parser.rl"
+#line 2528 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, false)); }
 	break;
 	case 35:
-#line 2570 "upb/json/parser.rl"
+#line 2530 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_null(parser)); }
 	break;
 	case 36:
-#line 2572 "upb/json/parser.rl"
+#line 2532 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_subobject_full(parser)); }
 	break;
 	case 37:
-#line 2573 "upb/json/parser.rl"
+#line 2533 "upb/json/parser.rl"
 	{ end_subobject_full(parser); }
 	break;
 	case 38:
-#line 2578 "upb/json/parser.rl"
+#line 2538 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
-#line 2955 "upb/json/parser.c"
+#line 2915 "upb/json/parser.c"
 		}
 	}
 
@@ -2968,32 +2928,32 @@ _again:
 	while ( __nacts-- > 0 ) {
 		switch ( *__acts++ ) {
 	case 0:
-#line 2430 "upb/json/parser.rl"
+#line 2390 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; 	if ( p == pe )
 		goto _test_eof;
 goto _again;} }
 	break;
 	case 30:
-#line 2561 "upb/json/parser.rl"
+#line 2521 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_number(parser, p)); }
 	break;
 	case 33:
-#line 2566 "upb/json/parser.rl"
+#line 2526 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, true)); }
 	break;
 	case 34:
-#line 2568 "upb/json/parser.rl"
+#line 2528 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, false)); }
 	break;
 	case 35:
-#line 2570 "upb/json/parser.rl"
+#line 2530 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_null(parser)); }
 	break;
 	case 37:
-#line 2573 "upb/json/parser.rl"
+#line 2533 "upb/json/parser.rl"
 	{ end_subobject_full(parser); }
 	break;
-#line 2997 "upb/json/parser.c"
+#line 2957 "upb/json/parser.c"
 		}
 	}
 	}
@@ -3001,11 +2961,10 @@ goto _again;} }
 	_out: {}
 	}
 
-#line 2606 "upb/json/parser.rl"
+#line 2566 "upb/json/parser.rl"
 
   if (p != pe) {
-    upb_status_seterrf(&parser->status, "Parse error at '%.*s'\n", pe - p, p);
-    upb_env_reporterror(parser->env, &parser->status);
+    upb_status_seterrf(parser->status, "Parse error at '%.*s'\n", pe - p, p);
   } else {
     capture_suspend(parser, &p);
   }
@@ -3049,26 +3008,25 @@ static void json_parser_reset(upb_json_parser *p) {
 
   /* Emit Ragel initialization of the parser. */
   
-#line 3053 "upb/json/parser.c"
+#line 3012 "upb/json/parser.c"
 	{
 	cs = json_start;
 	top = 0;
 	}
 
-#line 2653 "upb/json/parser.rl"
+#line 2612 "upb/json/parser.rl"
   p->current_state = cs;
   p->parser_top = top;
   accumulate_clear(p);
   p->multipart_state = MULTIPART_INACTIVE;
   p->capture = NULL;
   p->accumulated = NULL;
-  upb_status_clear(&p->status);
 }
 
 static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
                                                const upb_msgdef *md) {
   upb_msg_field_iter i;
-  upb_alloc *alloc = upb_arena_alloc(&c->arena);
+  upb_alloc *alloc = upb_arena_alloc(c->arena);
 
   upb_json_parsermethod *m = upb_malloc(alloc, sizeof(*m));
 
@@ -3109,19 +3067,20 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
 
 /* Public API *****************************************************************/
 
-upb_json_parser *upb_json_parser_create(upb_env *env,
+upb_json_parser *upb_json_parser_create(upb_arena *arena,
                                         const upb_json_parsermethod *method,
                                         const upb_symtab* symtab,
                                         upb_sink output,
                                         bool ignore_json_unknown) {
 #ifndef NDEBUG
-  const size_t size_before = upb_env_bytesallocated(env);
+  const size_t size_before = upb_arena_bytesallocated(arena);
 #endif
-  upb_json_parser *p = upb_env_malloc(env, sizeof(upb_json_parser));
+  upb_json_parser *p = upb_arena_malloc(arena, sizeof(upb_json_parser));
   if (!p) return false;
 
-  p->env = env;
+  p->arena = arena;
   p->method = method;
+  p->status = NULL;
   p->limit = p->stack + UPB_JSON_MAX_DEPTH;
   p->accumulate_buf = NULL;
   p->accumulate_buf_size = 0;
@@ -3143,8 +3102,8 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   p->ignore_json_unknown = ignore_json_unknown;
 
   /* If this fails, uncomment and increase the value in parser.h. */
-  /* fprintf(stderr, "%zd\n", upb_env_bytesallocated(env) - size_before); */
-  UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(env) - size_before <=
+  /* fprintf(stderr, "%zd\n", upb_arena_bytesallocated(arena) - size_before); */
+  UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(arena) - size_before <=
                       UPB_JSON_PARSER_SIZE);
   return p;
 }
@@ -3164,8 +3123,8 @@ upb_json_codecache *upb_json_codecache_new() {
 
   c = upb_gmalloc(sizeof(*c));
 
-  upb_arena_init(&c->arena);
-  alloc = upb_arena_alloc(&c->arena);
+  c->arena = upb_arena_new();
+  alloc = upb_arena_alloc(c->arena);
 
   upb_inttable_init2(&c->methods, UPB_CTYPE_CONSTPTR, alloc);
 
@@ -3173,7 +3132,7 @@ upb_json_codecache *upb_json_codecache_new() {
 }
 
 void upb_json_codecache_free(upb_json_codecache *c) {
-  upb_arena_uninit(&c->arena);
+  upb_arena_free(c->arena);
   upb_gfree(c);
 }
 
@@ -3182,7 +3141,7 @@ const upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
   upb_json_parsermethod *m;
   upb_value v;
   upb_msg_field_iter i;
-  upb_alloc *alloc = upb_arena_alloc(&c->arena);
+  upb_alloc *alloc = upb_arena_alloc(c->arena);
 
   if (upb_inttable_lookupptr(&c->methods, md, &v)) {
     return upb_value_getconstptr(v);
diff --git a/upb/json/parser.h b/upb/json/parser.h
index d1a1471..2a06fcf 100644
--- a/upb/json/parser.h
+++ b/upb/json/parser.h
@@ -25,14 +25,15 @@ class ParserMethodPtr;
 struct upb_json_parsermethod;
 typedef struct upb_json_parsermethod upb_json_parsermethod;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 const upb_byteshandler* upb_json_parsermethod_inputhandler(
     const upb_json_parsermethod* m);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 class upb::json::ParserMethodPtr {
  public:
@@ -62,17 +63,19 @@ class upb::json::ParserMethodPtr {
 struct upb_json_parser;
 typedef struct upb_json_parser upb_json_parser;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-upb_json_parser*
-upb_json_parser_create(upb_env* e, const upb_json_parsermethod* m,
-                       const upb_symtab* symtab, upb_sink output,
-                       bool ignore_json_unknown);
+upb_json_parser* upb_json_parser_create(upb_arena* a,
+                                        const upb_json_parsermethod* m,
+                                        const upb_symtab* symtab,
+                                        upb_sink output,
+                                        bool ignore_json_unknown);
 upb_bytessink upb_json_parser_input(upb_json_parser* p);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Parses an incoming BytesStream, pushing the results to the destination
  * sink. */
@@ -80,12 +83,13 @@ class upb::json::ParserPtr {
  public:
   ParserPtr(upb_json_parser* ptr) : ptr_(ptr) {}
 
-  static ParserPtr Create(Environment* env, ParserMethodPtr method,
+  static ParserPtr Create(Arena* arena, ParserMethodPtr method,
                           SymbolTable* symtab, Sink output,
                           bool ignore_json_unknown) {
     upb_symtab* symtab_ptr = symtab ? symtab->ptr() : nullptr;
-    return ParserPtr(upb_json_parser_create(
-        env, method.ptr(), symtab_ptr, output.sink(), ignore_json_unknown));
+    return ParserPtr(upb_json_parser_create(arena->ptr(), method.ptr(),
+                                            symtab_ptr, output.sink(),
+                                            ignore_json_unknown));
   }
 
   BytesSink input() { return upb_json_parser_input(ptr_); }
@@ -101,16 +105,17 @@ class upb::json::ParserPtr {
 struct upb_json_codecache;
 typedef struct upb_json_codecache upb_json_codecache;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 upb_json_codecache *upb_json_codecache_new();
 void upb_json_codecache_free(upb_json_codecache *cache);
 const upb_json_parsermethod* upb_json_codecache_get(upb_json_codecache* cache,
                                                     const upb_msgdef* md);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 class upb::json::CodeCache {
  public:
diff --git a/upb/json/parser.rl b/upb/json/parser.rl
index 05a9505..a117d0c 100644
--- a/upb/json/parser.rl
+++ b/upb/json/parser.rl
@@ -210,7 +210,7 @@ typedef struct {
 } upb_jsonparser_frame;
 
 struct upb_json_parser {
-  upb_env *env;
+  upb_arena *arena;
   const upb_json_parsermethod *method;
   upb_bytessink input_;
 
@@ -219,7 +219,7 @@ struct upb_json_parser {
   upb_jsonparser_frame *top;
   upb_jsonparser_frame *limit;
 
-  upb_status status;
+  upb_status *status;
 
   /* Ragel's internal parsing stack for the parsing state machine. */
   int current_state;
@@ -257,7 +257,7 @@ struct upb_json_parser {
 };
 
 struct upb_json_codecache {
-  upb_arena arena;
+  upb_arena *arena;
   upb_inttable methods;   /* upb_msgdef* -> upb_json_parsermethod* */
 };
 
@@ -275,7 +275,7 @@ static upb_jsonparser_any_frame *json_parser_any_frame_new(
     upb_json_parser *p) {
   upb_jsonparser_any_frame *frame;
 
-  frame = upb_env_malloc(p->env, sizeof(upb_jsonparser_any_frame));
+  frame = upb_arena_malloc(p->arena, sizeof(upb_jsonparser_any_frame));
 
   frame->encoder_handlercache = upb_pb_encoder_newcache();
   frame->parser_codecache = upb_json_codecache_new();
@@ -299,12 +299,12 @@ static void json_parser_any_frame_set_payload_type(
 
   /* Initialize encoder. */
   h = upb_handlercache_get(frame->encoder_handlercache, payload_type);
-  encoder = upb_pb_encoder_create(p->env, h, frame->stringsink.sink);
+  encoder = upb_pb_encoder_create(p->arena, h, frame->stringsink.sink);
 
   /* Initialize parser. */
   parser_method = upb_json_codecache_get(frame->parser_codecache, payload_type);
   upb_sink_reset(&frame->sink, h, encoder);
-  frame->parser = upb_json_parser_create(p->env, parser_method, p->symtab,
+  frame->parser = upb_json_parser_create(p->arena, parser_method, p->symtab,
                                          frame->sink, p->ignore_json_unknown);
 }
 
@@ -370,8 +370,7 @@ static upb_selector_t parser_getsel(upb_json_parser *p) {
 
 static bool check_stack(upb_json_parser *p) {
   if ((p->top + 1) == p->limit) {
-    upb_status_seterrmsg(&p->status, "Nesting too deep");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Nesting too deep");
     return false;
   }
 
@@ -466,10 +465,9 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
     char output[3];
 
     if (limit - ptr < 4) {
-      upb_status_seterrf(&p->status,
+      upb_status_seterrf(p->status,
                          "Base64 input for bytes field not a multiple of 4: %s",
                          upb_fielddef_name(p->top->f));
-      upb_env_reporterror(p->env, &p->status);
       return false;
     }
 
@@ -493,10 +491,9 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
 otherchar:
   if (nonbase64(ptr[0]) || nonbase64(ptr[1]) || nonbase64(ptr[2]) ||
       nonbase64(ptr[3]) ) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Non-base64 characters in bytes field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   } if (ptr[2] == '=') {
     uint32_t val;
@@ -534,11 +531,10 @@ otherchar:
   }
 
 badpadding:
-  upb_status_seterrf(&p->status,
+  upb_status_seterrf(p->status,
                      "Incorrect base64 padding for field: %s (%.*s)",
                      upb_fielddef_name(p->top->f),
                      4, ptr);
-  upb_env_reporterror(p->env, &p->status);
   return false;
 }
 
@@ -582,10 +578,9 @@ static bool accumulate_realloc(upb_json_parser *p, size_t need) {
     new_size = saturating_multiply(new_size, 2);
   }
 
-  mem = upb_env_realloc(p->env, p->accumulate_buf, old_size, new_size);
+  mem = upb_arena_realloc(p->arena, p->accumulate_buf, old_size, new_size);
   if (!mem) {
-    upb_status_seterrmsg(&p->status, "Out of memory allocating buffer.");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Out of memory allocating buffer.");
     return false;
   }
 
@@ -608,8 +603,7 @@ static bool accumulate_append(upb_json_parser *p, const char *buf, size_t len,
   }
 
   if (!checked_add(p->accumulated_len, len, &need)) {
-    upb_status_seterrmsg(&p->status, "Integer overflow.");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "Integer overflow.");
     return false;
   }
 
@@ -687,8 +681,7 @@ static bool multipart_text(upb_json_parser *p, const char *buf, size_t len,
   switch (p->multipart_state) {
     case MULTIPART_INACTIVE:
       upb_status_seterrmsg(
-          &p->status, "Internal error: unexpected state MULTIPART_INACTIVE");
-      upb_env_reporterror(p->env, &p->status);
+          p->status, "Internal error: unexpected state MULTIPART_INACTIVE");
       return false;
 
     case MULTIPART_ACCUMULATE:
@@ -1053,8 +1046,7 @@ static bool parse_number(upb_json_parser *p, bool is_quoted) {
     multipart_end(p);
     return true;
   } else {
-    upb_status_seterrf(&p->status, "error parsing number: %s", buf);
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrf(p->status, "error parsing number: %s", buf);
     multipart_end(p);
     return false;
   }
@@ -1068,10 +1060,9 @@ static bool parser_putbool(upb_json_parser *p, bool val) {
   }
 
   if (upb_fielddef_type(p->top->f) != UPB_TYPE_BOOL) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Boolean value specified for non-bool field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1246,10 +1237,9 @@ static bool start_stringval(upb_json_parser *p) {
     multipart_startaccum(p);
     return true;
   } else {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "String specified for bool or submessage field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 }
@@ -1282,8 +1272,7 @@ static bool end_any_stringval(upb_json_parser *p) {
     payload_type = upb_symtab_lookupmsg2(p->symtab, buf, len);
     if (payload_type == NULL) {
       upb_status_seterrf(
-          &p->status, "Cannot find packed type: %.*s\n", (int)len, buf);
-      upb_env_reporterror(p->env, &p->status);
+          p->status, "Cannot find packed type: %.*s\n", (int)len, buf);
       return false;
     }
 
@@ -1292,8 +1281,7 @@ static bool end_any_stringval(upb_json_parser *p) {
     return true;
   } else {
     upb_status_seterrf(
-        &p->status, "Invalid type url: %.*s\n", (int)len, buf);
-    upb_env_reporterror(p->env, &p->status);
+        p->status, "Invalid type url: %.*s\n", (int)len, buf);
     return false;
   }
 }
@@ -1345,8 +1333,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
         upb_selector_t sel = parser_getsel(p);
         upb_sink_putint32(&p->top->sink, sel, int_val);
       } else {
-        upb_status_seterrf(&p->status, "Enum value unknown: '%.*s'", len, buf);
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrf(p->status, "Enum value unknown: '%.*s'", len, buf);
       }
 
       break;
@@ -1363,8 +1350,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
 
     default:
       UPB_ASSERT(false);
-      upb_status_seterrmsg(&p->status, "Internal error in JSON decoder");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrmsg(p->status, "Internal error in JSON decoder");
       ok = false;
       break;
   }
@@ -1443,25 +1429,22 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   memcpy(seconds_buf, buf, fraction_start);
   seconds = strtol(seconds_buf, &end, 10);
   if (errno == ERANGE || end != seconds_buf + fraction_start) {
-    upb_status_seterrf(&p->status, "error parsing duration: %s",
+    upb_status_seterrf(p->status, "error parsing duration: %s",
                        seconds_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
   if (seconds > 315576000000) {
-    upb_status_seterrf(&p->status, "error parsing duration: "
+    upb_status_seterrf(p->status, "error parsing duration: "
                                    "maximum acceptable value is "
                                    "315576000000");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
   if (seconds < -315576000000) {
-    upb_status_seterrf(&p->status, "error parsing duration: "
+    upb_status_seterrf(p->status, "error parsing duration: "
                                    "minimum acceptable value is "
                                    "-315576000000");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1470,9 +1453,8 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   memcpy(nanos_buf + 1, buf + fraction_start, len - fraction_start);
   val = strtod(nanos_buf, &end);
   if (errno == ERANGE || end != nanos_buf + len - fraction_start + 1) {
-    upb_status_seterrf(&p->status, "error parsing duration: %s",
+    upb_status_seterrf(p->status, "error parsing duration: %s",
                        nanos_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1498,7 +1480,7 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
   end_member(p);
 
-  /* Continue previous environment */
+  /* Continue previous arena */
   multipart_startaccum(p);
 
   return true;
@@ -1528,8 +1510,7 @@ static bool end_timestamp_base(upb_json_parser *p, const char *ptr) {
 
   /* Parse seconds */
   if (strptime(timestamp_buf, "%FT%H:%M:%S%Z", &p->tm) == NULL) {
-    upb_status_seterrf(&p->status, "error parsing timestamp: %s", buf);
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrf(p->status, "error parsing timestamp: %s", buf);
     return false;
   }
 
@@ -1562,9 +1543,8 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   buf = accumulate_getptr(p, &len);
 
   if (len > 10) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
         "error parsing timestamp: at most 9-digit fraction.");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1574,9 +1554,8 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   val = strtod(nanos_buf, &end);
 
   if (errno == ERANGE || end != nanos_buf + len + 1) {
-    upb_status_seterrf(&p->status, "error parsing timestamp nanos: %s",
+    upb_status_seterrf(p->status, "error parsing timestamp nanos: %s",
                        nanos_buf);
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1618,8 +1597,7 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
 
   if (buf[0] != 'Z') {
     if (sscanf(buf + 1, "%2d:00", &hours) != 1) {
-      upb_status_seterrf(&p->status, "error parsing timestamp offset");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrf(p->status, "error parsing timestamp offset");
       return false;
     }
 
@@ -1635,10 +1613,9 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
 
   /* Check timestamp boundary */
   if (seconds < -62135596800) {
-    upb_status_seterrf(&p->status, "error parsing timestamp: "
+    upb_status_seterrf(p->status, "error parsing timestamp: "
                                    "minimum acceptable value is "
                                    "0001-01-01T00:00:00Z");
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -1679,8 +1656,7 @@ static bool parse_mapentry_key(upb_json_parser *p) {
 
   p->top->f = upb_msgdef_itof(p->top->m, UPB_MAPENTRY_KEY);
   if (p->top->f == NULL) {
-    upb_status_seterrmsg(&p->status, "mapentry message has no key");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "mapentry message has no key");
     return false;
   }
   switch (upb_fielddef_type(p->top->f)) {
@@ -1703,9 +1679,8 @@ static bool parse_mapentry_key(upb_json_parser *p) {
           return false;
         }
       } else {
-        upb_status_seterrmsg(&p->status,
+        upb_status_seterrmsg(p->status,
                              "Map bool key not 'true' or 'false'");
-        upb_env_reporterror(p->env, &p->status);
         return false;
       }
       multipart_end(p);
@@ -1723,8 +1698,7 @@ static bool parse_mapentry_key(upb_json_parser *p) {
       break;
     }
     default:
-      upb_status_seterrmsg(&p->status, "Invalid field type for map key");
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrmsg(p->status, "Invalid field type for map key");
       return false;
   }
 
@@ -1783,8 +1757,7 @@ static bool handle_mapentry(upb_json_parser *p) {
   p->top->is_mapentry = true;  /* set up to pop frame after value is parsed. */
   p->top->mapfield = mapfield;
   if (p->top->f == NULL) {
-    upb_status_seterrmsg(&p->status, "mapentry message has no value");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "mapentry message has no value");
     return false;
   }
 
@@ -1819,8 +1792,7 @@ static bool end_membername(upb_json_parser *p) {
       multipart_end(p);
       return true;
     } else {
-      upb_status_seterrf(&p->status, "No such field: %.*s\n", (int)len, buf);
-      upb_env_reporterror(p->env, &p->status);
+      upb_status_seterrf(p->status, "No such field: %.*s\n", (int)len, buf);
       return false;
     }
   }
@@ -1846,14 +1818,13 @@ static bool end_any_membername(upb_json_parser *p) {
 static void end_member(upb_json_parser *p) {
   /* If we just parsed a map-entry value, end that frame too. */
   if (p->top->is_mapentry) {
-    upb_status s = UPB_STATUS_INIT;
     upb_selector_t sel;
     bool ok;
     const upb_fielddef *mapfield;
 
     UPB_ASSERT(p->top > p->stack);
     /* send ENDMSG on submsg. */
-    upb_sink_endmsg(&p->top->sink, &s);
+    upb_sink_endmsg(&p->top->sink, p->status);
     mapfield = p->top->mapfield;
 
     /* send ENDSUBMSG in repeated-field-of-mapentries frame. */
@@ -1947,10 +1918,9 @@ static bool start_subobject(upb_json_parser *p) {
 
     return true;
   } else {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Object specified for non-message/group field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 }
@@ -2058,10 +2028,9 @@ static bool start_array(upb_json_parser *p) {
   }
 
   if (!upb_fielddef_isseq(p->top->f)) {
-    upb_status_seterrf(&p->status,
+    upb_status_seterrf(p->status,
                        "Array specified for non-repeated field: %s",
                        upb_fielddef_name(p->top->f));
-    upb_env_reporterror(p->env, &p->status);
     return false;
   }
 
@@ -2120,12 +2089,7 @@ static void start_object(upb_json_parser *p) {
 
 static void end_object(upb_json_parser *p) {
   if (!p->top->is_map && p->top->m != NULL) {
-    upb_status status;
-    upb_status_clear(&status);
-    upb_sink_endmsg(&p->top->sink, &status);
-    if (!upb_ok(&status)) {
-      upb_env_reporterror(p->env, &status);
-    }
+    upb_sink_endmsg(&p->top->sink, p->status);
   }
 }
 
@@ -2144,8 +2108,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
 
   if (json_parser_any_frame_has_value(p->top->any_frame) &&
       !json_parser_any_frame_has_type_url(p->top->any_frame)) {
-    upb_status_seterrmsg(&p->status, "No valid type url");
-    upb_env_reporterror(p->env, &p->status);
+    upb_status_seterrmsg(p->status, "No valid type url");
     return false;
   }
 
@@ -2160,8 +2123,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
                  p->top->any_frame->before_type_url_end -
                  p->top->any_frame->before_type_url_start);
       if (p->top->any_frame->before_type_url_start == NULL) {
-        upb_status_seterrmsg(&p->status, "invalid data for well known type.");
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrmsg(p->status, "invalid data for well known type.");
         return false;
       }
       p->top->any_frame->before_type_url_start++;
@@ -2173,8 +2135,7 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
                  (ptr + 1) -
                  p->top->any_frame->after_type_url_start);
       if (p->top->any_frame->after_type_url_start == NULL) {
-        upb_status_seterrmsg(&p->status, "Invalid data for well known type.");
-        upb_env_reporterror(p->env, &p->status);
+        upb_status_seterrmsg(p->status, "Invalid data for well known type.");
         return false;
       }
       p->top->any_frame->after_type_url_start++;
@@ -2247,7 +2208,6 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
 
   /* Deallocate any parse frame. */
   json_parser_any_frame_free(p->top->any_frame);
-  upb_env_free(p->env, p->top->any_frame);
 
   return true;
 }
@@ -2605,8 +2565,7 @@ size_t parse(void *closure, const void *hd, const char *buf, size_t size,
   %% write exec;
 
   if (p != pe) {
-    upb_status_seterrf(&parser->status, "Parse error at '%.*s'\n", pe - p, p);
-    upb_env_reporterror(parser->env, &parser->status);
+    upb_status_seterrf(parser->status, "Parse error at '%.*s'\n", pe - p, p);
   } else {
     capture_suspend(parser, &p);
   }
@@ -2656,13 +2615,12 @@ static void json_parser_reset(upb_json_parser *p) {
   p->multipart_state = MULTIPART_INACTIVE;
   p->capture = NULL;
   p->accumulated = NULL;
-  upb_status_clear(&p->status);
 }
 
 static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
                                                const upb_msgdef *md) {
   upb_msg_field_iter i;
-  upb_alloc *alloc = upb_arena_alloc(&c->arena);
+  upb_alloc *alloc = upb_arena_alloc(c->arena);
 
   upb_json_parsermethod *m = upb_malloc(alloc, sizeof(*m));
 
@@ -2703,19 +2661,20 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
 
 /* Public API *****************************************************************/
 
-upb_json_parser *upb_json_parser_create(upb_env *env,
+upb_json_parser *upb_json_parser_create(upb_arena *arena,
                                         const upb_json_parsermethod *method,
                                         const upb_symtab* symtab,
                                         upb_sink output,
                                         bool ignore_json_unknown) {
 #ifndef NDEBUG
-  const size_t size_before = upb_env_bytesallocated(env);
+  const size_t size_before = upb_arena_bytesallocated(arena);
 #endif
-  upb_json_parser *p = upb_env_malloc(env, sizeof(upb_json_parser));
+  upb_json_parser *p = upb_arena_malloc(arena, sizeof(upb_json_parser));
   if (!p) return false;
 
-  p->env = env;
+  p->arena = arena;
   p->method = method;
+  p->status = NULL;
   p->limit = p->stack + UPB_JSON_MAX_DEPTH;
   p->accumulate_buf = NULL;
   p->accumulate_buf_size = 0;
@@ -2737,8 +2696,8 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   p->ignore_json_unknown = ignore_json_unknown;
 
   /* If this fails, uncomment and increase the value in parser.h. */
-  /* fprintf(stderr, "%zd\n", upb_env_bytesallocated(env) - size_before); */
-  UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(env) - size_before <=
+  /* fprintf(stderr, "%zd\n", upb_arena_bytesallocated(arena) - size_before); */
+  UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(arena) - size_before <=
                       UPB_JSON_PARSER_SIZE);
   return p;
 }
@@ -2758,8 +2717,8 @@ upb_json_codecache *upb_json_codecache_new() {
 
   c = upb_gmalloc(sizeof(*c));
 
-  upb_arena_init(&c->arena);
-  alloc = upb_arena_alloc(&c->arena);
+  c->arena = upb_arena_new();
+  alloc = upb_arena_alloc(c->arena);
 
   upb_inttable_init2(&c->methods, UPB_CTYPE_CONSTPTR, alloc);
 
@@ -2767,7 +2726,7 @@ upb_json_codecache *upb_json_codecache_new() {
 }
 
 void upb_json_codecache_free(upb_json_codecache *c) {
-  upb_arena_uninit(&c->arena);
+  upb_arena_free(c->arena);
   upb_gfree(c);
 }
 
@@ -2776,7 +2735,7 @@ const upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
   upb_json_parsermethod *m;
   upb_value v;
   upb_msg_field_iter i;
-  upb_alloc *alloc = upb_arena_alloc(&c->arena);
+  upb_alloc *alloc = upb_arena_alloc(c->arena);
 
   if (upb_inttable_lookupptr(&c->methods, md, &v)) {
     return upb_value_getconstptr(v);
diff --git a/upb/json/printer.c b/upb/json/printer.c
index 83f1a58..bc18055 100644
--- a/upb/json/printer.c
+++ b/upb/json/printer.c
@@ -1252,13 +1252,13 @@ static void json_printer_reset(upb_json_printer *p) {
 
 /* Public API *****************************************************************/
 
-upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
+upb_json_printer *upb_json_printer_create(upb_arena *a, const upb_handlers *h,
                                           upb_bytessink output) {
 #ifndef NDEBUG
-  size_t size_before = upb_env_bytesallocated(e);
+  size_t size_before = upb_arena_bytesallocated(a);
 #endif
 
-  upb_json_printer *p = upb_env_malloc(e, sizeof(upb_json_printer));
+  upb_json_printer *p = upb_arena_malloc(a, sizeof(upb_json_printer));
   if (!p) return NULL;
 
   p->output_ = output;
@@ -1268,7 +1268,7 @@ upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
   p->nanos = 0;
 
   /* If this fails, increase the value in printer.h. */
-  UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(e) - size_before <=
+  UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(a) - size_before <=
                       UPB_JSON_PRINTER_SIZE);
   return p;
 }
diff --git a/upb/json/printer.h b/upb/json/printer.h
index a7a37bb..857ae47 100644
--- a/upb/json/printer.h
+++ b/upb/json/printer.h
@@ -24,10 +24,12 @@ class PrinterPtr;
 struct upb_json_printer;
 typedef struct upb_json_printer upb_json_printer;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /* Native C API. */
-upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
+upb_json_printer *upb_json_printer_create(upb_arena *a, const upb_handlers *h,
                                           upb_bytessink output);
 upb_sink upb_json_printer_input(upb_json_printer *p);
 const upb_handlers *upb_json_printer_newhandlers(const upb_msgdef *md,
@@ -36,18 +38,18 @@ const upb_handlers *upb_json_printer_newhandlers(const upb_msgdef *md,
 
 upb_handlercache *upb_json_printer_newcache(bool preserve_proto_fieldnames);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Prints an incoming stream of data to a BytesSink in JSON format. */
 class upb::json::PrinterPtr {
  public:
   PrinterPtr(upb_json_printer* ptr) : ptr_(ptr) {}
 
-  static PrinterPtr Create(Environment *env, const upb::Handlers *handlers,
+  static PrinterPtr Create(Arena *arena, const upb::Handlers *handlers,
                            BytesSink output) {
-    return PrinterPtr(upb_json_printer_create(env, handlers, output.sink()));
+    return PrinterPtr(
+        upb_json_printer_create(arena->ptr(), handlers, output.sink()));
   }
 
   /* The input to the printer. */
diff --git a/upb/msg.h b/upb/msg.h
index 4529478..149b7ab 100644
--- a/upb/msg.h
+++ b/upb/msg.h
@@ -37,18 +37,22 @@ class MessageLayout;
 
 #endif
 
-UPB_DECLARE_TYPE(upb::Map, upb_map)
-UPB_DECLARE_TYPE(upb::MapIterator, upb_mapiter)
-
-struct upb_array;
-typedef struct upb_array upb_array;
-
 /* TODO(haberman): C++ accessors */
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 typedef void upb_msg;
 
+struct upb_array;
+typedef struct upb_array upb_array;
+
+struct upb_map;
+typedef struct upb_map upb_map;
+
+struct upb_mapiter;
+typedef struct upb_mapiter upb_mapiter;
 
 /** upb_msglayout *************************************************************/
 
@@ -75,7 +79,6 @@ typedef struct upb_msglayout {
   bool extendable;
 } upb_msglayout;
 
-
 /** upb_stringview ************************************************************/
 
 typedef struct {
@@ -103,7 +106,6 @@ UPB_INLINE bool upb_stringview_eql(upb_stringview a, upb_stringview b) {
 
 #define UPB_STRINGVIEW_INIT(ptr, len) {ptr, len}
 
-
 /** upb_msgval ****************************************************************/
 
 /* A union representing all possible protobuf values.  Used for generic get/set
@@ -156,7 +158,6 @@ UPB_INLINE upb_msgval upb_msgval_makestr(const char *data, size_t size) {
   return upb_msgval_str(upb_stringview_make(data, size));
 }
 
-
 /** upb_msg *******************************************************************/
 
 /* A upb_msg represents a protobuf message.  It always corresponds to a specific
@@ -216,7 +217,6 @@ bool upb_msg_clearfield(upb_msg *msg,
 
 /* TODO(haberman): copyfrom()/mergefrom()? */
 
-
 /** upb_array *****************************************************************/
 
 /* A upb_array stores data for a repeated field.  The memory management
@@ -236,7 +236,6 @@ upb_msgval upb_array_get(const upb_array *arr, size_t i);
 
 bool upb_array_set(upb_array *arr, size_t i, upb_msgval val);
 
-
 /** upb_map *******************************************************************/
 
 /* A upb_map stores data for a map field.  The memory management semantics are
@@ -268,7 +267,6 @@ bool upb_map_set(upb_map *map,
 /* Deletes an entry in the map.  Returns true if the key was present. */
 bool upb_map_del(upb_map *map, upb_msgval key);
 
-
 /** upb_mapiter ***************************************************************/
 
 /* For iterating over a map.  Map iterators are invalidated by mutations to the
@@ -290,6 +288,8 @@ upb_msgval upb_mapiter_value(const upb_mapiter *i);
 void upb_mapiter_setdone(upb_mapiter *i);
 bool upb_mapiter_isequal(const upb_mapiter *i1, const upb_mapiter *i2);
 
-UPB_END_EXTERN_C
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #endif /* UPB_MSG_H_ */
diff --git a/upb/msgfactory.h b/upb/msgfactory.h
index 73a26ba..9b3b599 100644
--- a/upb/msgfactory.h
+++ b/upb/msgfactory.h
@@ -5,10 +5,15 @@
 #ifndef UPB_MSGFACTORY_H_
 #define UPB_MSGFACTORY_H_
 
-UPB_DECLARE_TYPE(upb::MessageFactory, upb_msgfactory)
-
 /** upb_msgfactory ************************************************************/
 
+struct upb_msgfactory;
+typedef struct upb_msgfactory upb_msgfactory;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* A upb_msgfactory contains a cache of upb_msglayout, upb_handlers, and
  * upb_visitorplan objects.  These are the objects necessary to represent,
  * populate, and and visit upb_msg objects.
@@ -36,5 +41,8 @@ const upb_symtab *upb_msgfactory_symtab(const upb_msgfactory *f);
 const upb_msglayout *upb_msgfactory_getlayout(upb_msgfactory *f,
                                               const upb_msgdef *m);
 
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #endif /* UPB_MSGFACTORY_H_ */
diff --git a/upb/pb/compile_decoder.c b/upb/pb/compile_decoder.c
index e17ca03..ca497ed 100644
--- a/upb/pb/compile_decoder.c
+++ b/upb/pb/compile_decoder.c
@@ -907,7 +907,7 @@ upb_pbcodecache *upb_pbcodecache_new(upb_handlercache *dest) {
   c->allow_jit = true;
   c->lazy = false;
 
-  upb_arena_init(&c->arena);
+  c->arena = upb_arena_new();
   if (!upb_inttable_init(&c->groups, UPB_CTYPE_CONSTPTR)) return NULL;
 
   return c;
diff --git a/upb/pb/decoder.c b/upb/pb/decoder.c
index cd64f72..5068225 100644
--- a/upb/pb/decoder.c
+++ b/upb/pb/decoder.c
@@ -99,9 +99,7 @@ static bool in_residual_buf(const upb_pbdecoder *d, const char *p);
  * benchmarks. */
 
 static void seterr(upb_pbdecoder *d, const char *msg) {
-  upb_status status = UPB_STATUS_INIT;
-  upb_status_seterrmsg(&status, msg);
-  upb_env_reporterror(d->env, &status);
+  upb_status_seterrmsg(d->status, msg);
 }
 
 void upb_pbdecoder_seterr(upb_pbdecoder *d, const char *msg) {
@@ -992,24 +990,24 @@ void upb_pbdecoder_reset(upb_pbdecoder *d) {
   d->residual_end = d->residual;
 }
 
-upb_pbdecoder *upb_pbdecoder_create(upb_env *e, const upb_pbdecodermethod *m,
+upb_pbdecoder *upb_pbdecoder_create(upb_arena *a, const upb_pbdecodermethod *m,
                                     upb_sink sink) {
   const size_t default_max_nesting = 64;
 #ifndef NDEBUG
-  size_t size_before = upb_env_bytesallocated(e);
+  size_t size_before = upb_arena_bytesallocated(a);
 #endif
 
-  upb_pbdecoder *d = upb_env_malloc(e, sizeof(upb_pbdecoder));
+  upb_pbdecoder *d = upb_arena_malloc(a, sizeof(upb_pbdecoder));
   if (!d) return NULL;
 
   d->method_ = m;
-  d->callstack = upb_env_malloc(e, callstacksize(d, default_max_nesting));
-  d->stack = upb_env_malloc(e, stacksize(d, default_max_nesting));
+  d->callstack = upb_arena_malloc(a, callstacksize(d, default_max_nesting));
+  d->stack = upb_arena_malloc(a, stacksize(d, default_max_nesting));
   if (!d->stack || !d->callstack) {
     return NULL;
   }
 
-  d->env = e;
+  d->arena = a;
   d->limit = d->stack + default_max_nesting - 1;
   d->stack_size = default_max_nesting;
   d->status = NULL;
@@ -1024,7 +1022,7 @@ upb_pbdecoder *upb_pbdecoder_create(upb_env *e, const upb_pbdecodermethod *m,
   d->top->sink = sink;
 
   /* If this fails, increase the value in decoder.h. */
-  UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(e) - size_before <=
+  UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(a) - size_before <=
                       UPB_PB_DECODER_SIZE);
   return d;
 }
@@ -1057,7 +1055,7 @@ bool upb_pbdecoder_setmaxnesting(upb_pbdecoder *d, size_t max) {
     /* Need to reallocate stack and callstack to accommodate. */
     size_t old_size = stacksize(d, d->stack_size);
     size_t new_size = stacksize(d, max);
-    void *p = upb_env_realloc(d->env, d->stack, old_size, new_size);
+    void *p = upb_arena_realloc(d->arena, d->stack, old_size, new_size);
     if (!p) {
       return false;
     }
@@ -1065,7 +1063,7 @@ bool upb_pbdecoder_setmaxnesting(upb_pbdecoder *d, size_t max) {
 
     old_size = callstacksize(d, d->stack_size);
     new_size = callstacksize(d, max);
-    p = upb_env_realloc(d->env, d->callstack, old_size, new_size);
+    p = upb_arena_realloc(d->arena, d->callstack, old_size, new_size);
     if (!p) {
       return false;
     }
diff --git a/upb/pb/decoder.h b/upb/pb/decoder.h
index ba381f3..6fcef03 100644
--- a/upb/pb/decoder.h
+++ b/upb/pb/decoder.h
@@ -40,7 +40,9 @@ class DecoderMethodOptions;
 struct upb_pbdecodermethod;
 typedef struct upb_pbdecodermethod upb_pbdecodermethod;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 const upb_handlers *upb_pbdecodermethod_desthandlers(
     const upb_pbdecodermethod *m);
@@ -48,9 +50,8 @@ const upb_byteshandler *upb_pbdecodermethod_inputhandler(
     const upb_pbdecodermethod *m);
 bool upb_pbdecodermethod_isnative(const upb_pbdecodermethod *m);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* Represents the code to parse a protobuf according to a destination
  * Handlers. */
@@ -95,9 +96,11 @@ class upb::pb::DecoderMethodPtr {
 struct upb_pbdecoder;
 typedef struct upb_pbdecoder upb_pbdecoder;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-upb_pbdecoder *upb_pbdecoder_create(upb_env *e,
+upb_pbdecoder *upb_pbdecoder_create(upb_arena *arena,
                                     const upb_pbdecodermethod *method,
                                     upb_sink output);
 const upb_pbdecodermethod *upb_pbdecoder_method(const upb_pbdecoder *d);
@@ -107,9 +110,8 @@ size_t upb_pbdecoder_maxnesting(const upb_pbdecoder *d);
 bool upb_pbdecoder_setmaxnesting(upb_pbdecoder *d, size_t max);
 void upb_pbdecoder_reset(upb_pbdecoder *d);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* A Decoder receives binary protobuf data on its input sink and pushes the
  * decoded data to its output sink. */
@@ -124,9 +126,10 @@ class upb::pb::DecoderPtr {
    * must also outlive this decoder.
    *
    * The sink must match the given method. */
-  static DecoderPtr Create(Environment *env, DecoderMethodPtr method,
+  static DecoderPtr Create(Arena *arena, DecoderMethodPtr method,
                            upb::Sink output) {
-    return DecoderPtr(upb_pbdecoder_create(env, method.ptr(), output.sink()));
+    return DecoderPtr(
+        upb_pbdecoder_create(arena->ptr(), method.ptr(), output.sink()));
   }
 
   /* Returns the DecoderMethod this decoder is parsing from. */
@@ -171,7 +174,9 @@ class upb::pb::DecoderPtr {
 struct upb_pbcodecache;
 typedef struct upb_pbcodecache upb_pbcodecache;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 upb_pbcodecache *upb_pbcodecache_new(upb_handlercache *dest);
 void upb_pbcodecache_free(upb_pbcodecache *c);
@@ -181,9 +186,8 @@ void upb_pbcodecache_setlazy(upb_pbcodecache *c, bool lazy);
 const upb_pbdecodermethod *upb_pbcodecache_get(upb_pbcodecache *c,
                                                const upb_msgdef *md);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* A class for caching protobuf processing code, whether bytecode for the
  * interpreted decoder or machine code for the JIT.
diff --git a/upb/pb/decoder.int.h b/upb/pb/decoder.int.h
index 8d464fa..47eb3ed 100644
--- a/upb/pb/decoder.int.h
+++ b/upb/pb/decoder.int.h
@@ -73,7 +73,7 @@ typedef enum {
 UPB_INLINE opcode getop(uint32_t instr) { return instr & 0xff; }
 
 struct upb_pbcodecache {
-  upb_arena arena;
+  upb_arena *arena;
   upb_handlercache *dest;
   bool allow_jit;
   bool lazy;
@@ -169,7 +169,7 @@ struct upb_pbdecodermethod {
 };
 
 struct upb_pbdecoder {
-  upb_env *env;
+  upb_arena *arena;
 
   /* Our input sink. */
   upb_bytessink input_;
diff --git a/upb/pb/encoder.c b/upb/pb/encoder.c
index 1496eba..722cc5b 100644
--- a/upb/pb/encoder.c
+++ b/upb/pb/encoder.c
@@ -91,7 +91,7 @@ typedef struct {
 } upb_pb_encoder_segment;
 
 struct upb_pb_encoder {
-  upb_env *env;
+  upb_arena *arena;
 
   /* Our input and output. */
   upb_sink input_;
@@ -150,7 +150,7 @@ static bool reserve(upb_pb_encoder *e, size_t bytes) {
       new_size *= 2;
     }
 
-    new_buf = upb_env_realloc(e->env, e->buf, old_size, new_size);
+    new_buf = upb_arena_realloc(e->arena, e->buf, old_size, new_size);
 
     if (new_buf == NULL) {
       return false;
@@ -230,7 +230,7 @@ static bool start_delim(upb_pb_encoder *e) {
           (e->seglimit - e->segbuf) * sizeof(upb_pb_encoder_segment);
       size_t new_size = old_size * 2;
       upb_pb_encoder_segment *new_buf =
-          upb_env_realloc(e->env, e->segbuf, old_size, new_size);
+          upb_arena_realloc(e->arena, e->segbuf, old_size, new_size);
 
       if (new_buf == NULL) {
         return false;
@@ -526,22 +526,22 @@ upb_handlercache *upb_pb_encoder_newcache() {
   return upb_handlercache_new(newhandlers_callback, NULL);
 }
 
-upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h,
+upb_pb_encoder *upb_pb_encoder_create(upb_arena *arena, const upb_handlers *h,
                                       upb_bytessink output) {
   const size_t initial_bufsize = 256;
   const size_t initial_segbufsize = 16;
   /* TODO(haberman): make this configurable. */
   const size_t stack_size = 64;
 #ifndef NDEBUG
-  const size_t size_before = upb_env_bytesallocated(env);
+  const size_t size_before = upb_arena_bytesallocated(arena);
 #endif
 
-  upb_pb_encoder *e = upb_env_malloc(env, sizeof(upb_pb_encoder));
+  upb_pb_encoder *e = upb_arena_malloc(arena, sizeof(upb_pb_encoder));
   if (!e) return NULL;
 
-  e->buf = upb_env_malloc(env, initial_bufsize);
-  e->segbuf = upb_env_malloc(env, initial_segbufsize * sizeof(*e->segbuf));
-  e->stack = upb_env_malloc(env, stack_size * sizeof(*e->stack));
+  e->buf = upb_arena_malloc(arena, initial_bufsize);
+  e->segbuf = upb_arena_malloc(arena, initial_segbufsize * sizeof(*e->segbuf));
+  e->stack = upb_arena_malloc(arena, stack_size * sizeof(*e->stack));
 
   if (!e->buf || !e->segbuf || !e->stack) {
     return NULL;
@@ -554,13 +554,13 @@ upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h,
   upb_pb_encoder_reset(e);
   upb_sink_reset(&e->input_, h, e);
 
-  e->env = env;
+  e->arena = arena;
   e->output_ = output;
   e->subc = output.closure;
   e->ptr = e->buf;
 
   /* If this fails, increase the value in encoder.h. */
-  UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(env) - size_before <=
+  UPB_ASSERT_DEBUGVAR(upb_arena_bytesallocated(arena) - size_before <=
                       UPB_PB_ENCODER_SIZE);
   return e;
 }
diff --git a/upb/pb/encoder.h b/upb/pb/encoder.h
index 7aa2870..780f60f 100644
--- a/upb/pb/encoder.h
+++ b/upb/pb/encoder.h
@@ -35,17 +35,18 @@ class EncoderPtr;
 struct upb_pb_encoder;
 typedef struct upb_pb_encoder upb_pb_encoder;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 upb_sink upb_pb_encoder_input(upb_pb_encoder *p);
-upb_pb_encoder* upb_pb_encoder_create(upb_env* e, const upb_handlers* h,
+upb_pb_encoder* upb_pb_encoder_create(upb_arena* a, const upb_handlers* h,
                                       upb_bytessink output);
 
 upb_handlercache *upb_pb_encoder_newcache();
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" { */
 
 class upb::pb::EncoderPtr {
  public:
@@ -55,9 +56,10 @@ class upb::pb::EncoderPtr {
 
   /* Creates a new encoder in the given environment.  The Handlers must have
    * come from NewHandlers() below. */
-  static EncoderPtr Create(Environment* env, const Handlers* handlers,
+  static EncoderPtr Create(Arena* arena, const Handlers* handlers,
                            BytesSink output) {
-    return EncoderPtr(upb_pb_encoder_create(env, handlers, output.sink()));
+    return EncoderPtr(
+        upb_pb_encoder_create(arena->ptr(), handlers, output.sink()));
   }
 
   /* The input to the encoder. */
diff --git a/upb/pb/textprinter.c b/upb/pb/textprinter.c
index d1d539d..91d0d55 100644
--- a/upb/pb/textprinter.c
+++ b/upb/pb/textprinter.c
@@ -18,7 +18,7 @@
 
 struct upb_textprinter {
   upb_sink input_;
-  upb_bytessink *output_;
+  upb_bytessink output_;
   int indent_depth_;
   bool single_line_;
   void *subc;
@@ -35,13 +35,13 @@ static int indent(upb_textprinter *p) {
   int i;
   if (!p->single_line_)
     for (i = 0; i < p->indent_depth_; i++)
-      upb_bytessink_putbuf(p->output_, p->subc, "  ", 2, NULL);
+      upb_bytessink_putbuf(&p->output_, p->subc, "  ", 2, NULL);
   return 0;
 }
 
 static int endfield(upb_textprinter *p) {
   const char ch = (p->single_line_ ? ' ' : '\n');
-  upb_bytessink_putbuf(p->output_, p->subc, &ch, 1, NULL);
+  upb_bytessink_putbuf(&p->output_, p->subc, &ch, 1, NULL);
   return 0;
 }
 
@@ -60,7 +60,7 @@ static int putescaped(upb_textprinter *p, const char *buf, size_t len,
     bool is_hex_escape;
 
     if (dstend - dst < 4) {
-      upb_bytessink_putbuf(p->output_, p->subc, dstbuf, dst - dstbuf, NULL);
+      upb_bytessink_putbuf(&p->output_, p->subc, dstbuf, dst - dstbuf, NULL);
       dst = dstbuf;
     }
 
@@ -88,7 +88,7 @@ static int putescaped(upb_textprinter *p, const char *buf, size_t len,
     last_hex_escape = is_hex_escape;
   }
   /* Flush remaining data. */
-  upb_bytessink_putbuf(p->output_, p->subc, dstbuf, dst - dstbuf, NULL);
+  upb_bytessink_putbuf(&p->output_, p->subc, dstbuf, dst - dstbuf, NULL);
   return 0;
 }
 
@@ -114,7 +114,7 @@ bool putf(upb_textprinter *p, const char *fmt, ...) {
   va_end(args);
   UPB_ASSERT(written == len);
 
-  ok = upb_bytessink_putbuf(p->output_, p->subc, str, len, NULL);
+  ok = upb_bytessink_putbuf(&p->output_, p->subc, str, len, NULL);
   upb_gfree(str);
   return ok;
 }
@@ -126,7 +126,7 @@ static bool textprinter_startmsg(void *c, const void *hd) {
   upb_textprinter *p = c;
   UPB_UNUSED(hd);
   if (p->indent_depth_ == 0) {
-    upb_bytessink_start(p->output_, 0, &p->subc);
+    upb_bytessink_start(&p->output_, 0, &p->subc);
   }
   return true;
 }
@@ -136,7 +136,7 @@ static bool textprinter_endmsg(void *c, const void *hd, upb_status *s) {
   UPB_UNUSED(hd);
   UPB_UNUSED(s);
   if (p->indent_depth_ == 0) {
-    upb_bytessink_end(p->output_);
+    upb_bytessink_end(&p->output_);
   }
   return true;
 }
@@ -241,7 +241,7 @@ static bool textprinter_endsubmsg(void *closure, const void *handler_data) {
   UPB_UNUSED(handler_data);
   p->indent_depth_--;
   CHECK(indent(p));
-  upb_bytessink_putbuf(p->output_, p->subc, "}", 1, NULL);
+  upb_bytessink_putbuf(&p->output_, p->subc, "}", 1, NULL);
   CHECK(endfield(p));
   return true;
 err:
@@ -315,9 +315,9 @@ static void textprinter_reset(upb_textprinter *p, bool single_line) {
 
 /* Public API *****************************************************************/
 
-upb_textprinter *upb_textprinter_create(upb_env *env, const upb_handlers *h,
-                                        upb_bytessink *output) {
-  upb_textprinter *p = upb_env_malloc(env, sizeof(upb_textprinter));
+upb_textprinter *upb_textprinter_create(upb_arena *arena, const upb_handlers *h,
+                                        upb_bytessink output) {
+  upb_textprinter *p = upb_arena_malloc(arena, sizeof(upb_textprinter));
   if (!p) return NULL;
 
   p->output_ = output;
@@ -331,7 +331,7 @@ upb_handlercache *upb_textprinter_newcache() {
   return upb_handlercache_new(&onmreg, NULL);
 }
 
-upb_sink *upb_textprinter_input(upb_textprinter *p) { return &p->input_; }
+upb_sink upb_textprinter_input(upb_textprinter *p) { return p->input_; }
 
 void upb_textprinter_setsingleline(upb_textprinter *p, bool single_line) {
   p->single_line_ = single_line;
diff --git a/upb/pb/textprinter.h b/upb/pb/textprinter.h
index 06ff7d5..e59e11d 100644
--- a/upb/pb/textprinter.h
+++ b/upb/pb/textprinter.h
@@ -17,60 +17,51 @@ class TextPrinter;
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::pb::TextPrinter, upb_textprinter)
+/* upb_textprinter ************************************************************/
+
+struct upb_textprinter;
+typedef struct upb_textprinter upb_textprinter;
 
 #ifdef __cplusplus
+extern "C" {
+#endif
 
-class upb::pb::TextPrinter {
+/* C API. */
+upb_textprinter *upb_textprinter_create(upb_arena *arena, const upb_handlers *h,
+                                        upb_bytessink output);
+void upb_textprinter_setsingleline(upb_textprinter *p, bool single_line);
+upb_sink upb_textprinter_input(upb_textprinter *p);
+upb_handlercache *upb_textprinter_newcache();
+
+#ifdef __cplusplus
+}  /* extern "C" */
+
+class upb::pb::TextPrinterPtr {
  public:
+  TextPrinterPtr(upb_textprinter* ptr) : ptr_(ptr) {}
+
   /* The given handlers must have come from NewHandlers().  It must outlive the
    * TextPrinter. */
-  static TextPrinter *Create(Environment *env, const upb::Handlers *handlers,
-                             BytesSink *output);
+  static TextPrinterPtr *Create(Arena *arena, const upb::Handlers *handlers,
+                             BytesSink output) {
+    return TextPrinterPtr(upb_textprinter_create(arena, handlers, output));
+  }
 
-  void SetSingleLineMode(bool single_line);
+  void SetSingleLineMode(bool single_line) {
+    upb_textprinter_setsingleline(ptr_, single_line);
+  }
 
-  Sink* input();
+  Sink input() { return upb_textprinter_input(ptr_); }
 
   /* If handler caching becomes a requirement we can add a code cache as in
    * decoder.h */
-  static HandlerCache* NewCache();
-};
-
-#endif
-
-UPB_BEGIN_EXTERN_C
+  static HandlerCache NewCache() {
+    return HandlerCache(upb_textprinter_newcache());
+  }
 
-/* C API. */
-upb_textprinter *upb_textprinter_create(upb_env *env, const upb_handlers *h,
-                                        upb_bytessink *output);
-void upb_textprinter_setsingleline(upb_textprinter *p, bool single_line);
-upb_sink *upb_textprinter_input(upb_textprinter *p);
-
-upb_handlercache *upb_textprinter_newcache();
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-namespace upb {
-namespace pb {
-inline TextPrinter *TextPrinter::Create(Environment *env,
-                                        const upb::Handlers *handlers,
-                                        BytesSink *output) {
-  return upb_textprinter_create(env, handlers, output);
-}
-inline void TextPrinter::SetSingleLineMode(bool single_line) {
-  upb_textprinter_setsingleline(this, single_line);
-}
-inline Sink* TextPrinter::input() {
-  return upb_textprinter_input(this);
-}
-inline HandlerCache* TextPrinter::NewCache() {
-  return upb_textprinter_newcache();
-}
-}  /* namespace pb */
-}  /* namespace upb */
+ private:
+  upb_textprinter* ptr_;
+};
 
 #endif
 
diff --git a/upb/sink.c b/upb/sink.c
index 6ef5718..7a7eeb4 100644
--- a/upb/sink.c
+++ b/upb/sink.c
@@ -15,73 +15,3 @@ bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink sink) {
   }
   return ret;
 }
-
-struct upb_bufsink {
-  upb_byteshandler handler;
-  upb_bytessink sink;
-  upb_env *env;
-  char *ptr;
-  size_t len, size;
-};
-
-static void *upb_bufsink_start(void *_sink, const void *hd, size_t size_hint) {
-  upb_bufsink *sink = _sink;
-  UPB_UNUSED(hd);
-  UPB_UNUSED(size_hint);
-  sink->len = 0;
-  return sink;
-}
-
-static size_t upb_bufsink_string(void *_sink, const void *hd, const char *ptr,
-                                size_t len, const upb_bufhandle *handle) {
-  upb_bufsink *sink = _sink;
-  size_t new_size = sink->size;
-
-  UPB_ASSERT(new_size > 0);
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  while (sink->len + len > new_size) {
-    new_size *= 2;
-  }
-
-  if (new_size != sink->size) {
-    sink->ptr = upb_env_realloc(sink->env, sink->ptr, sink->size, new_size);
-    sink->size = new_size;
-  }
-
-  memcpy(sink->ptr + sink->len, ptr, len);
-  sink->len += len;
-
-  return len;
-}
-
-upb_bufsink *upb_bufsink_new(upb_env *env) {
-  upb_bufsink *sink = upb_env_malloc(env, sizeof(upb_bufsink));
-  upb_byteshandler_init(&sink->handler);
-  upb_byteshandler_setstartstr(&sink->handler, upb_bufsink_start, NULL);
-  upb_byteshandler_setstring(&sink->handler, upb_bufsink_string, NULL);
-
-  upb_bytessink_reset(&sink->sink, &sink->handler, sink);
-
-  sink->env = env;
-  sink->size = 32;
-  sink->ptr = upb_env_malloc(env, sink->size);
-  sink->len = 0;
-
-  return sink;
-}
-
-void upb_bufsink_free(upb_bufsink *sink) {
-  upb_env_free(sink->env, sink->ptr);
-  upb_env_free(sink->env, sink);
-}
-
-upb_bytessink *upb_bufsink_sink(upb_bufsink *sink) {
-  return &sink->sink;
-}
-
-const char *upb_bufsink_getdata(const upb_bufsink *sink, size_t *len) {
-  *len = sink->len;
-  return sink->ptr;
-}
diff --git a/upb/sink.h b/upb/sink.h
index 1855542..d93d966 100644
--- a/upb/sink.h
+++ b/upb/sink.h
@@ -29,7 +29,9 @@ class Sink;
 
 /* upb_sink *******************************************************************/
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 typedef struct {
   const upb_handlers *handlers;
@@ -192,9 +194,8 @@ UPB_INLINE bool upb_sink_endsubmsg(upb_sink *s, upb_selector_t sel) {
   return endsubmsg(s->closure, hd);
 }
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 /* 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.
@@ -288,7 +289,9 @@ class upb::Sink {
    *   sink->EndMessage(&status);
    *   sink->EndSubMessage(endsubmsg_selector); */
   bool StartMessage() { return upb_sink_startmsg(&sink_); }
-  bool EndMessage(Status* status) { return upb_sink_endmsg(&sink_, status); }
+  bool EndMessage(upb_status *status) {
+    return upb_sink_endmsg(&sink_, status);
+  }
 
   /* Putting of individual values.  These work for both repeated and
    * non-repeated fields, but for repeated fields you must wrap them in
@@ -489,13 +492,14 @@ class upb::BytesSink {
 
 /* upb_bufsrc *****************************************************************/
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink sink);
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 namespace upb {
 template <class T> bool PutBuffer(const T& str, BytesSink sink) {
@@ -505,19 +509,4 @@ template <class T> bool PutBuffer(const T& str, BytesSink sink) {
 
 #endif  /* __cplusplus */
 
-/* upb_bufsink ****************************************************************/
-
-/* A class for accumulating output string data in a flat buffer. */
-struct upb_bufsink;
-typedef struct upb_bufsink upb_bufsink;
-
-UPB_BEGIN_EXTERN_C
-
-upb_bufsink *upb_bufsink_init(upb_env *env);
-void upb_bufsink_free(upb_bufsink *sink);
-upb_bytessink *upb_bufsink_sink(upb_bufsink *sink);
-const char *upb_bufsink_getdata(const upb_bufsink *sink, size_t *len);
-
-UPB_END_EXTERN_C
-
 #endif
diff --git a/upb/table.int.h b/upb/table.int.h
index 63dce59..2b86390 100644
--- a/upb/table.int.h
+++ b/upb/table.int.h
@@ -156,21 +156,6 @@ UPB_INLINE upb_value upb_value_double(double cval) {
  * initializing a non-first union member. */
 typedef uintptr_t upb_tabkey;
 
-#define UPB_TABKEY_NUM(n) n
-#define UPB_TABKEY_NONE 0
-/* The preprocessor isn't quite powerful enough to turn the compile-time string
- * length into a byte-wise string representation, so code generation needs to
- * help it along.
- *
- * "len1" is the low byte and len4 is the high byte. */
-#ifdef UPB_BIG_ENDIAN
-#define UPB_TABKEY_STR(len1, len2, len3, len4, strval) \
-    (uintptr_t)(len4 len3 len2 len1 strval)
-#else
-#define UPB_TABKEY_STR(len1, len2, len3, len4, strval) \
-    (uintptr_t)(len1 len2 len3 len4 strval)
-#endif
-
 UPB_INLINE char *upb_tabstr(upb_tabkey key, uint32_t *len) {
   char* mem = (char*)key;
   if (len) memcpy(len, mem, sizeof(*len));
diff --git a/upb/upb.c b/upb/upb.c
index 68e26b0..f56f6c4 100644
--- a/upb/upb.c
+++ b/upb/upb.c
@@ -8,12 +8,6 @@
 #include <string.h>
 #include "upb/upb.h"
 
-bool upb_dumptostderr(void *closure, const upb_status* status) {
-  UPB_UNUSED(closure);
-  fprintf(stderr, "%s\n", upb_status_errmsg(status));
-  return false;
-}
-
 /* Guarantee null-termination and provide ellipsis truncation.
  * It may be tempting to "optimize" this by initializing these final
  * four bytes up-front and then being careful never to overwrite them,
@@ -29,24 +23,17 @@ static void nullz(upb_status *status) {
 
 void upb_status_clear(upb_status *status) {
   if (!status) return;
-  status->ok_ = true;
-  status->code_ = 0;
+  status->ok = true;
   status->msg[0] = '\0';
 }
 
-bool upb_ok(const upb_status *status) { return status->ok_; }
-
-upb_errorspace *upb_status_errspace(const upb_status *status) {
-  return status->error_space_;
-}
-
-int upb_status_errcode(const upb_status *status) { return status->code_; }
+bool upb_ok(const upb_status *status) { return status->ok; }
 
 const char *upb_status_errmsg(const upb_status *status) { return status->msg; }
 
 void upb_status_seterrmsg(upb_status *status, const char *msg) {
   if (!status) return;
-  status->ok_ = false;
+  status->ok = false;
   strncpy(status->msg, msg, sizeof(status->msg));
   nullz(status);
 }
@@ -60,17 +47,11 @@ void upb_status_seterrf(upb_status *status, const char *fmt, ...) {
 
 void upb_status_vseterrf(upb_status *status, const char *fmt, va_list args) {
   if (!status) return;
-  status->ok_ = false;
+  status->ok = false;
   _upb_vsnprintf(status->msg, sizeof(status->msg), fmt, args);
   nullz(status);
 }
 
-void upb_status_copy(upb_status *to, const upb_status *from) {
-  if (!to) return;
-  *to = *from;
-}
-
-
 /* upb_alloc ******************************************************************/
 
 static void *upb_global_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
@@ -87,7 +68,6 @@ static void *upb_global_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
 
 upb_alloc upb_alloc_global = {&upb_global_allocfunc};
 
-
 /* upb_arena ******************************************************************/
 
 /* Be conservative and choose 16 in case anyone is using SSE. */
@@ -115,11 +95,7 @@ struct upb_arena {
 
   /* Cleanup entries.  Pointer to a cleanup_ent, defined in env.c */
   void *cleanup_head;
-
-  /* For future expansion, since the size of this struct is exposed to users. */
-  void *future1;
-  void *future2;
-} upb_arena;
+};
 
 typedef struct mem_block {
   struct mem_block *next;
@@ -149,7 +125,6 @@ static void upb_arena_addblock(upb_arena *a, void *ptr, size_t size,
   /* TODO(haberman): ASAN poison. */
 }
 
-
 static mem_block *upb_arena_allocblock(upb_arena *a, size_t size) {
   size_t block_size = UPB_MAX(size, a->next_block_size) + sizeof(mem_block);
   mem_block *block = upb_malloc(a->block_alloc, block_size);
@@ -202,7 +177,25 @@ static void *upb_arena_doalloc(upb_alloc *alloc, void *ptr, size_t oldsize,
 
 /* Public Arena API ***********************************************************/
 
-void upb_arena_init(upb_arena *a) {
+upb_arena *upb_arena_init(void *mem, size_t n, upb_alloc *alloc) {
+  const size_t first_block_overhead = sizeof(upb_arena) + sizeof(mem_block);
+  upb_arena *a;
+  bool owned = false;
+
+  if (n < first_block_overhead) {
+    /* We need to malloc the initial block. */
+    n = first_block_overhead + 256;
+    owned = true;
+    if (!alloc || !(mem = upb_malloc(alloc, n))) {
+      return NULL;
+    }
+  }
+
+  a = mem;
+  mem = (char*)mem + sizeof(*a);
+  n -= sizeof(*a);
+  upb_arena_addblock(a, mem, n, owned);
+
   a->alloc.func = &upb_arena_doalloc;
   a->block_alloc = &upb_alloc_global;
   a->bytes_allocated = 0;
@@ -210,21 +203,12 @@ void upb_arena_init(upb_arena *a) {
   a->max_block_size = 16384;
   a->cleanup_head = NULL;
   a->block_head = NULL;
-}
-
-void upb_arena_init2(upb_arena *a, void *mem, size_t size, upb_alloc *alloc) {
-  upb_arena_init(a);
+  a->block_alloc = alloc;
 
-  if (size > sizeof(mem_block)) {
-    upb_arena_addblock(a, mem, size, false);
-  }
-
-  if (alloc) {
-    a->block_alloc = alloc;
-  }
+  return a;
 }
 
-void upb_arena_uninit(upb_arena *a) {
+void upb_arena_free(upb_arena *a) {
   cleanup_ent *ent = a->cleanup_head;
   mem_block *block = a->block_head;
 
@@ -236,6 +220,7 @@ void upb_arena_uninit(upb_arena *a) {
   /* Must do this after running cleanup functions, because this will delete
    * the memory we store our cleanup entries in! */
   while (block) {
+    /* Load first since we are deleting block. */
     mem_block *next = block->next;
 
     if (block->owned) {
@@ -244,10 +229,6 @@ void upb_arena_uninit(upb_arena *a) {
 
     block = next;
   }
-
-  /* Protect against multiple-uninit. */
-  a->cleanup_head = NULL;
-  a->block_head = NULL;
 }
 
 bool upb_arena_addcleanup(upb_arena *a, upb_cleanup_func *func, void *ud) {
diff --git a/upb/upb.h b/upb/upb.h
index 4384812..07b0455 100644
--- a/upb/upb.h
+++ b/upb/upb.h
@@ -15,14 +15,11 @@
 #include <stdint.h>
 
 #ifdef __cplusplus
+#include <memory>
 namespace upb {
-class Allocator;
 class Arena;
-class Environment;
-class ErrorSpace;
 class Status;
 template <int N> class InlinedArena;
-template <int N> class InlinedEnvironment;
 }
 #endif
 
@@ -74,46 +71,14 @@ template <int N> class InlinedEnvironment;
 #error Need implementations of [v]snprintf and va_copy
 #endif
 
-#if (defined(__cplusplus) && __cplusplus >= 201103L) || \
-    defined(__GXX_EXPERIMENTAL_CXX0X__) ||              \
+#ifdef __cplusplus
+#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) || \
     (defined(_MSC_VER) && _MSC_VER >= 1900)
 // C++11 is present
 #else
 #error upb requires C++11 for C++ support
 #endif
-
-/* UPB_DISALLOW_COPY_AND_ASSIGN()
- * UPB_DISALLOW_POD_OPS()
- *
- * Declare these in the "private" section of a C++ class to forbid copy/assign
- * or all POD ops (construct, destruct, copy, assign) on that class. */
-#include <type_traits>
-#define UPB_DISALLOW_COPY_AND_ASSIGN(class_name) \
-  class_name(const class_name&) = delete; \
-  void operator=(const class_name&) = delete;
-#define UPB_DISALLOW_POD_OPS(class_name, full_class_name) \
-  class_name() = delete; \
-  ~class_name() = delete; \
-  UPB_DISALLOW_COPY_AND_ASSIGN(class_name)
-#define UPB_ASSERT_STDLAYOUT(type) \
-  static_assert(std::is_standard_layout<type>::value, \
-                #type " must be standard layout");
-
-#ifdef __cplusplus
-
-#define UPB_BEGIN_EXTERN_C extern "C" {
-#define UPB_END_EXTERN_C }
-#define UPB_DECLARE_TYPE(cppname, cname) typedef cppname cname;
-
-#else  /* !defined(__cplusplus) */
-
-#define UPB_BEGIN_EXTERN_C
-#define UPB_END_EXTERN_C
-#define UPB_DECLARE_TYPE(cppname, cname) \
-  struct cname;                          \
-  typedef struct cname cname;
-
-#endif  /* defined(__cplusplus) */
+#endif
 
 #define UPB_MAX(x, y) ((x) > (y) ? (x) : (y))
 #define UPB_MIN(x, y) ((x) < (y) ? (x) : (y))
@@ -138,21 +103,26 @@ template <int N> class InlinedEnvironment;
 #define UPB_UNREACHABLE() do { assert(0); } while(0)
 #endif
 
-/* upb::Status ****************************************************************/
+/* upb_status *****************************************************************/
 
-/* upb::Status represents a success or failure status and error message.
+/* upb_status represents a success or failure status and error message.
  * It owns no resources and allocates no memory, so it should work
  * even in OOM situations. */
-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
+#define UPB_STATUS_MAX_MESSAGE 127
 
-UPB_BEGIN_EXTERN_C
+typedef struct {
+  bool ok;
+  char msg[UPB_STATUS_MAX_MESSAGE];  /* Error message; NULL-terminated. */
+} upb_status;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 const char *upb_status_errmsg(const upb_status *status);
 bool upb_ok(const upb_status *status);
-int upb_status_errcode(const upb_status *status);
 
 /* Any of the functions that write to a status object allow status to be NULL,
  * to support use cases where the function's caller does not care about the
@@ -161,60 +131,44 @@ void upb_status_clear(upb_status *status);
 void upb_status_seterrmsg(upb_status *status, const char *msg);
 void upb_status_seterrf(upb_status *status, const char *fmt, ...);
 void upb_status_vseterrf(upb_status *status, const char *fmt, va_list args);
-void upb_status_copy(upb_status *to, const upb_status *from);
 
-UPB_END_EXTERN_C
+UPB_INLINE void upb_status_setoom(upb_status *status) {
+  upb_status_seterrmsg(status, "out of memory");
+}
 
 #ifdef __cplusplus
+}  /* extern "C" */
 
 class upb::Status {
  public:
-  Status() { upb_status_clear(this); }
+  Status() { upb_status_clear(&status_); }
 
-  /* Returns true if there is no error. */
-  bool ok() const { return upb_ok(this); }
+  upb_status* ptr() { return &status_; }
 
-  /* Optional error space and code, useful if the caller wants to
-   * programmatically check the specific kind of error. */
-  ErrorSpace* error_space() { return upb_status_errspace(this); }
-  int error_code() const { return upb_status_errcode(this); }
+  /* Returns true if there is no error. */
+  bool ok() const { return upb_ok(&status_); }
 
-  /* The returned string is invalidated by any other call into the status. */
-  const char *error_message() const { return upb_status_errmsg(this); }
+  /* Guaranteed to be NULL-terminated. */
+  const char *error_message() const { return upb_status_errmsg(&status_); }
 
   /* The error message will be truncated if it is longer than
    * UPB_STATUS_MAX_MESSAGE-4. */
-  void SetErrorMessage(const char* msg) { upb_status_seterrmsg(this, msg); }
-  void SetFormattedErrorMessage(const char* fmt, ...) {
+  void SetErrorMessage(const char *msg) { upb_status_seterrmsg(&status_, msg); }
+  void SetFormattedErrorMessage(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    upb_status_vseterrf(this, fmt, args);
+    upb_status_vseterrf(&status_, fmt, args);
     va_end(args);
   }
 
   /* Resets the status to a successful state with no message. */
-  void Clear() { upb_status_clear(this); }
-
-  void CopyFrom(const Status& other) { upb_status_copy(this, &other); }
+  void Clear() { upb_status_clear(&status_); }
 
  private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Status)
-#else
-struct upb_status {
-#endif
-  bool ok_;
-
-  /* Specific status code defined by some error space (optional). */
-  int code_;
-  upb_errorspace *error_space_;
-
-  /* TODO(haberman): add file/line of error? */
-
-  /* Error message; NULL-terminated. */
-  char msg[UPB_STATUS_MAX_MESSAGE];
+  upb_status status_;
 };
 
-#define UPB_STATUS_INIT {true, 0, NULL, {0}}
+#endif  /* __cplusplus */
 
 /** upb_alloc *****************************************************************/
 
@@ -291,17 +245,23 @@ UPB_INLINE void upb_gfree(void *ptr) {
 typedef void upb_cleanup_func(void *ud);
 
 struct upb_arena;
-typedef upb_arena upb_arena;
+typedef struct upb_arena upb_arena;
 
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-upb_arena *upb_arena_new2(void *mem, size_t n, upb_alloc *alloc);
+/* Creates an arena from the given initial block (if any -- n may be 0).
+ * Additional blocks will be allocated from |alloc|.  If |alloc| is NULL, this
+ * is a fixed-size arena and cannot grow. */
+upb_arena *upb_arena_init(void *mem, size_t n, upb_alloc *alloc);
 void upb_arena_free(upb_arena *a);
 bool upb_arena_addcleanup(upb_arena *a, upb_cleanup_func *func, void *ud);
 size_t upb_arena_bytesallocated(const upb_arena *a);
 
 UPB_INLINE upb_alloc *upb_arena_alloc(upb_arena *a) { return (upb_alloc*)a; }
 
+/* Convenience wrappers around upb_alloc functions. */
 UPB_INLINE void *upb_arena_malloc(upb_arena *a, size_t size) {
   return upb_malloc(upb_arena_alloc(a), size);
 }
@@ -312,52 +272,38 @@ UPB_INLINE void *upb_arena_realloc(upb_arena *a, void *ptr, size_t oldsize,
 }
 
 UPB_INLINE upb_arena *upb_arena_new() {
-  return upb_arena_new2(NULL, 0, &upb_alloc_global);
+  return upb_arena_init(NULL, 0, &upb_alloc_global);
 }
 
-UPB_END_EXTERN_C
-
 #ifdef __cplusplus
+}  /* extern "C" */
 
 class upb::Arena {
  public:
   /* A simple arena with no initial memory block and the default allocator. */
-  Arena() { upb_arena_init(&arena_); }
+  Arena() : ptr_(upb_arena_new(), upb_arena_free) {}
 
-  upb_arena* ptr() { return &arena_; }
-
-  /* Constructs an arena with the given initial block which allocates blocks
-   * with the given allocator.  The given allocator must outlive the Arena.
-   *
-   * If you pass NULL for the allocator it will default to the global allocator
-   * upb_alloc_global, and NULL/0 for the initial block will cause there to be
-   * no initial block. */
-  Arena(void *mem, size_t len, upb_alloc *a) {
-    upb_arena_init2(&arena_, mem, len, a);
-  }
-
-  ~Arena() { upb_arena_uninit(&arena_); }
+  upb_arena* ptr() { return ptr_.get(); }
 
   /* Allows this arena to be used as a generic allocator.
    *
    * The arena does not need free() calls so when using Arena as an allocator
    * it is safe to skip them.  However they are no-ops so there is no harm in
    * calling free() either. */
-  upb_alloc *allocator() { return upb_arena_alloc(&arena_); }
+  upb_alloc *allocator() { return upb_arena_alloc(ptr_.get()); }
 
   /* Add a cleanup function to run when the arena is destroyed.
    * Returns false on out-of-memory. */
   bool AddCleanup(upb_cleanup_func *func, void *ud) {
-    return upb_arena_addcleanup(&arena_, func, ud);
+    return upb_arena_addcleanup(ptr_.get(), func, ud);
   }
 
   /* Total number of bytes that have been allocated.  It is undefined what
    * Realloc() does to &arena_ counter. */
-  size_t BytesAllocated() const { return upb_arena_bytesallocated(&arena_); }
+  size_t BytesAllocated() const { return upb_arena_bytesallocated(ptr_.get()); }
 
  private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(Arena)
-  upb_arena arena_;
+  std::unique_ptr<upb_arena, decltype(&upb_arena_free)> ptr_;
 };
 
 #endif
@@ -373,13 +319,16 @@ class upb::Arena {
 
 template <int N> class upb::InlinedArena : public upb::Arena {
  public:
-  InlinedArena() : Arena(initial_block_, N, NULL) {}
-  explicit InlinedArena(Allocator* a) : Arena(initial_block_, N, a) {}
+  InlinedArena() : ptr_(upb_arena_new(&initial_block_, N, &upb_alloc_global)) {}
+
+  upb_arena* ptr() { return ptr_.get(); }
 
  private:
-  UPB_DISALLOW_COPY_AND_ASSIGN(InlinedArena)
+  InlinedArena(const InlinedArena*) = delete;
+  InlinedArena& operator=(const InlinedArena*) = delete;
 
-  char initial_block_[N + UPB_ARENA_BLOCK_OVERHEAD];
+  std::unique_ptr<upb_arena, decltype(&upb_arena_free)> ptr_;
+  char initial_block_[N];
 };
 
 #endif  /* __cplusplus */
author	Joshua Haberman <jhaberman@gmail.com>	2019-01-14 10:56:58 -0800
committer	Joshua Haberman <jhaberman@gmail.com>	2019-01-14 10:56:58 -0800
commit	cb26d883d1290ed258e5594454c2ffe0526b13f9 (patch)
tree	8ca8c172333c159d8bf6c4e315376cdfb2f66882 /upb
parent	a9c375f8ea81e52d832653c963da72033c9a98be (diff)