From d2f9bec5c6f3c34362cf13e35e11d3dbc7888a32 Mon Sep 17 00:00:00 2001
From: Joshua Haberman <jhaberman@gmail.com>
Date: Sat, 12 Jan 2019 16:15:46 -0800
Subject: Removed old-style C++ handlers that relied on UB in favor of more
 normal ones.

---
 upb/sink.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'upb/sink.c')

diff --git a/upb/sink.c b/upb/sink.c
index e6ede49..d0197a6 100644
--- a/upb/sink.c
+++ b/upb/sink.c
@@ -4,9 +4,8 @@
 bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink) {
   void *subc;
   bool ret;
-  upb_bufhandle handle;
-  upb_bufhandle_init(&handle);
-  upb_bufhandle_setbuf(&handle, buf, 0);
+  upb_bufhandle handle = UPB_BUFHANDLE_INIT;
+  handle.buf = buf;
   ret = upb_bytessink_start(sink, len, &subc);
   if (ret && len != 0) {
     ret = (upb_bytessink_putbuf(sink, subc, buf, len, &handle) >= len);
@@ -14,7 +13,6 @@ bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink) {
   if (ret) {
     ret = upb_bytessink_end(sink);
   }
-  upb_bufhandle_uninit(&handle);
   return ret;
 }
 
-- 
cgit v1.2.3


From 48863ea0be94ea3d3d61206ad7ce9ead206770fa Mon Sep 17 00:00:00 2001
From: Joshua Haberman <jhaberman@gmail.com>
Date: Sat, 12 Jan 2019 19:12:57 -0800
Subject: A lot more tests are working now.

---
 BUILD                        |  10 ---
 tests/json/test_json.cc      |  36 +++++-----
 tests/pb/test_decoder.cc     | 157 ++++++++++++++++++++-----------------------
 tests/test_handlers.c        |  42 ------------
 tests/test_util.h            |  10 +--
 upb/bindings/stdc++/string.h |   3 +-
 upb/handlers-inl.h           |   2 +-
 upb/handlers.c               |  11 ++-
 upb/handlers.h               |   2 +
 upb/json/parser.c            | 144 ++++++++++++++++++++-------------------
 upb/json/parser.h            | 140 ++++++++++++++++++++------------------
 upb/json/parser.rl           |  38 ++++++-----
 upb/json/printer.c           |  32 +++++----
 upb/json/printer.h           |  68 ++++++++-----------
 upb/pb/decoder.c             |  11 ++-
 upb/pb/decoder.h             |  11 +--
 upb/pb/encoder.c             |  14 ++--
 upb/pb/encoder.h             |  12 ++--
 upb/sink.c                   |   8 +--
 upb/sink.h                   |  28 ++++++--
 20 files changed, 375 insertions(+), 404 deletions(-)
 delete mode 100644 tests/test_handlers.c

(limited to 'upb/sink.c')

diff --git a/BUILD b/BUILD
index ffb5bbd..c6c401c 100644
--- a/BUILD
+++ b/BUILD
@@ -166,16 +166,6 @@ upb_proto_reflection_library(
     deps = ["descriptor_proto"],
 )
 
-cc_test(
-    name = "test_handlers",
-    srcs = ["tests/test_handlers.c"],
-    deps = [
-        ":descriptor_upbproto",
-        ":upb_pb",
-        ":upb_test",
-    ],
-)
-
 proto_library(
     name = "test_decoder_proto",
     srcs = [
diff --git a/tests/json/test_json.cc b/tests/json/test_json.cc
index b9b50cd..b0fd3e3 100644
--- a/tests/json/test_json.cc
+++ b/tests/json/test_json.cc
@@ -144,7 +144,7 @@ class StringSink {
   }
   ~StringSink() { }
 
-  upb_bytessink* Sink() { return &bytessink_; }
+  upb_bytessink Sink() { return bytessink_; }
 
   const std::string& Data() { return s_; }
 
@@ -169,16 +169,15 @@ class StringSink {
 void test_json_roundtrip_message(const char* json_src,
                                  const char* json_expected,
                                  const upb::Handlers* serialize_handlers,
-                                 const upb::json::ParserMethod* parser_method,
+                                 const upb::json::ParserMethodPtr parser_method,
                                  int seam) {
   VerboseParserEnvironment env(verbose);
   StringSink data_sink;
-  upb::json::Printer* printer = upb::json::Printer::Create(
+  upb::json::PrinterPtr printer = upb::json::PrinterPtr::Create(
       env.env(), serialize_handlers, data_sink.Sink());
-  upb::json::Parser* parser =
-      upb::json::Parser::Create(
-          env.env(), parser_method, NULL, printer->input(), false);
-  env.ResetBytesSink(parser->input());
+  upb::json::ParserPtr parser = upb::json::ParserPtr::Create(
+      env.env(), parser_method, NULL, printer.input(), false);
+  env.ResetBytesSink(parser.input());
   env.Reset(json_src, strlen(json_src), false, false);
 
   bool ok = env.Start() &&
@@ -203,16 +202,16 @@ void test_json_roundtrip_message(const char* json_src,
 // Starts with a message in JSON format, parses and directly serializes again,
 // and compares the result.
 void test_json_roundtrip() {
-  upb::SymbolTable* symtab = upb::SymbolTable::New();
-  upb::HandlerCache* serialize_handlercache = upb::json::Printer::NewCache(false);
-  upb::json::CodeCache* parse_codecache = upb::json::CodeCache::New();
+  upb::SymbolTable symtab;
+  upb::HandlerCache serialize_handlercache(
+      upb::json::PrinterPtr::NewCache(false));
+  upb::json::CodeCache parse_codecache;
 
-  const upb::MessageDef* md = upb_test_json_TestMessage_getmsgdef(symtab);
+  upb::MessageDefPtr md(upb_test_json_TestMessage_getmsgdef(symtab.ptr()));
   ASSERT(md);
-  const upb::Handlers* serialize_handlers = serialize_handlercache->Get(md);
-  const upb::json::ParserMethod* parser_method = parse_codecache->Get(md);
+  const upb::Handlers* serialize_handlers = serialize_handlercache.Get(md);
+  const upb::json::ParserMethodPtr parser_method = parse_codecache.Get(md);
   ASSERT(serialize_handlers);
-  ASSERT(parser_method);
 
   for (const TestCase* test_case = kTestRoundtripMessages;
        test_case->input != NULL; test_case++) {
@@ -227,9 +226,8 @@ void test_json_roundtrip() {
     }
   }
 
-  upb::HandlerCache::Free(serialize_handlercache);
-  serialize_handlercache = upb::json::Printer::NewCache(true);
-  serialize_handlers = serialize_handlercache->Get(md);
+  serialize_handlercache = upb::json::PrinterPtr::NewCache(true);
+  serialize_handlers = serialize_handlercache.Get(md);
 
   for (const TestCase* test_case = kTestRoundtripMessagesPreserve;
        test_case->input != NULL; test_case++) {
@@ -243,10 +241,6 @@ void test_json_roundtrip() {
                                   serialize_handlers, parser_method, i);
     }
   }
-
-  upb::HandlerCache::Free(serialize_handlercache);
-  upb::json::CodeCache::Free(parse_codecache);
-  upb::SymbolTable::Free(symtab);
 }
 
 extern "C" {
diff --git a/tests/pb/test_decoder.cc b/tests/pb/test_decoder.cc
index d0e3fa3..ec7a788 100644
--- a/tests/pb/test_decoder.cc
+++ b/tests/pb/test_decoder.cc
@@ -279,7 +279,7 @@ int* startstr(int* depth, const uint32_t* num, size_t size_hint) {
 }
 
 size_t value_string(int* depth, const uint32_t* num, const char* buf,
-                    size_t n, const upb::BufferHandle* handle) {
+                    size_t n, const upb_bufhandle* handle) {
   UPB_UNUSED(num);
   UPB_UNUSED(depth);
   check_stack_alignment();
@@ -348,13 +348,13 @@ void free_uint32(void *val) {
 }
 
 template<class T, bool F(int*, const uint32_t*, T)>
-void doreg(upb_handlers *h, uint32_t num) {
-  const upb_fielddef *f = upb_msgdef_itof(upb_handlers_msgdef(h), num);
+void doreg(upb::HandlersPtr h, uint32_t num) {
+  upb::FieldDefPtr f = h.message_def().FindFieldByNumber(num);
   ASSERT(f);
-  ASSERT(h->SetValueHandler<T>(f, UpbBindT(F, new uint32_t(num))));
-  if (f->IsSequence()) {
-    ASSERT(h->SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
-    ASSERT(h->SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
+  ASSERT(h.SetValueHandler<T>(f, UpbBind(F, new uint32_t(num))));
+  if (f.IsSequence()) {
+    ASSERT(h.SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
+    ASSERT(h.SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
   }
 }
 
@@ -368,7 +368,7 @@ uint32_t rep_fn(uint32_t fn) {
 #define UNKNOWN_FIELD 666
 
 template <class T, bool F(int*, const uint32_t*, T)>
-void reg(upb_handlers *h, upb_descriptortype_t type) {
+void reg(upb::HandlersPtr h, upb_descriptortype_t type) {
   // We register both a repeated and a non-repeated field for every type.
   // For the non-repeated field we make the field number the same as the
   // type.  For the repeated field we make it a function of the type.
@@ -376,39 +376,40 @@ void reg(upb_handlers *h, upb_descriptortype_t type) {
   doreg<T, F>(h, rep_fn(type));
 }
 
-void regseq(upb::Handlers* h, const upb::FieldDef* f, uint32_t num) {
-  ASSERT(h->SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
-  ASSERT(h->SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
+void regseq(upb::HandlersPtr h, upb::FieldDefPtr f, uint32_t num) {
+  ASSERT(h.SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
+  ASSERT(h.SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
 }
 
-void reg_subm(upb_handlers *h, uint32_t num) {
-  const upb_fielddef *f = upb_msgdef_itof(upb_handlers_msgdef(h), num);
+void reg_subm(upb::HandlersPtr h, uint32_t num) {
+  upb::FieldDefPtr f = h.message_def().FindFieldByNumber(num);
   ASSERT(f);
-  if (f->IsSequence()) regseq(h, f, num);
+  if (f.IsSequence()) regseq(h, f, num);
   ASSERT(
-      h->SetStartSubMessageHandler(f, UpbBind(startsubmsg, new uint32_t(num))));
-  ASSERT(h->SetEndSubMessageHandler(f, UpbBind(endsubmsg, new uint32_t(num))));
+      h.SetStartSubMessageHandler(f, UpbBind(startsubmsg, new uint32_t(num))));
+  ASSERT(h.SetEndSubMessageHandler(f, UpbBind(endsubmsg, new uint32_t(num))));
 }
 
-void reg_str(upb_handlers *h, uint32_t num) {
-  const upb_fielddef *f = upb_msgdef_itof(upb_handlers_msgdef(h), num);
+void reg_str(upb::HandlersPtr h, uint32_t num) {
+  upb::FieldDefPtr f = h.message_def().FindFieldByNumber(num);
   ASSERT(f);
-  if (f->IsSequence()) regseq(h, f, num);
-  ASSERT(h->SetStartStringHandler(f, UpbBind(startstr, new uint32_t(num))));
-  ASSERT(h->SetEndStringHandler(f, UpbBind(endstr, new uint32_t(num))));
-  ASSERT(h->SetStringHandler(f, UpbBind(value_string, new uint32_t(num))));
+  if (f.IsSequence()) regseq(h, f, num);
+  ASSERT(h.SetStartStringHandler(f, UpbBind(startstr, new uint32_t(num))));
+  ASSERT(h.SetEndStringHandler(f, UpbBind(endstr, new uint32_t(num))));
+  ASSERT(h.SetStringHandler(f, UpbBind(value_string, new uint32_t(num))));
 }
 
 struct HandlerRegisterData {
   TestMode mode;
 };
 
-void callback(const void *closure, upb_handlers *h) {
+void callback(const void *closure, upb::Handlers* h_ptr) {
+  upb::HandlersPtr h(h_ptr);
   const HandlerRegisterData* data =
       static_cast<const HandlerRegisterData*>(closure);
   if (data->mode == ALL_HANDLERS) {
-    h->SetStartMessageHandler(UpbMakeHandler(startmsg));
-    h->SetEndMessageHandler(UpbMakeHandler(endmsg));
+    h.SetStartMessageHandler(UpbMakeHandler(startmsg));
+    h.SetEndMessageHandler(UpbMakeHandler(endmsg));
 
     // Register handlers for each type.
     reg<double,   value_double>(h, UPB_DESCRIPTOR_TYPE_DOUBLE);
@@ -436,7 +437,7 @@ void callback(const void *closure, upb_handlers *h) {
     reg_subm(h, UPB_DESCRIPTOR_TYPE_MESSAGE);
     reg_subm(h, rep_fn(UPB_DESCRIPTOR_TYPE_MESSAGE));
 
-    if (h->message_def()->full_name() == std::string("DecoderTest")) {
+    if (h.message_def().full_name() == std::string("DecoderTest")) {
       reg_subm(h, UPB_DESCRIPTOR_TYPE_GROUP);
       reg_subm(h, rep_fn(UPB_DESCRIPTOR_TYPE_GROUP));
     }
@@ -446,25 +447,16 @@ void callback(const void *closure, upb_handlers *h) {
   }
 }
 
-upb::reffed_ptr<const upb::Handlers> NewHandlers(upb::SymbolTable* symtab,
-                                                 TestMode mode) {
-  HandlerRegisterData handlerdata;
-  handlerdata.mode = mode;
-  return upb::Handlers::NewFrozen(DecoderTest_getmsgdef(symtab), callback,
-                                  &handlerdata);
-}
-
 /* Running of test cases ******************************************************/
 
 const upb::Handlers *global_handlers;
-const upb::pb::DecoderMethod *global_method;
-
-upb::pb::Decoder* CreateDecoder(upb::Environment* env,
-                                const upb::pb::DecoderMethod* method,
-                                upb::Sink* sink) {
-  upb::pb::Decoder *ret = upb::pb::Decoder::Create(env, method, sink);
-  ASSERT(ret != NULL);
-  ret->set_max_nesting(MAX_NESTING);
+upb::pb::DecoderMethodPtr global_method;
+
+upb::pb::DecoderPtr CreateDecoder(upb::Environment* env,
+                                  upb::pb::DecoderMethodPtr method,
+                                  upb::Sink sink) {
+  upb::pb::DecoderPtr ret = upb::pb::DecoderPtr::Create(env, method, sink);
+  ret.set_max_nesting(MAX_NESTING);
   return ret;
 }
 
@@ -479,7 +471,7 @@ uint32_t Hash(const string& proto, const string* expected_output, size_t seam1,
   return hash;
 }
 
-void CheckBytesParsed(const upb::pb::Decoder& decoder, size_t ofs) {
+void CheckBytesParsed(upb::pb::DecoderPtr decoder, size_t ofs) {
   // We can't have parsed more data than the decoder callback is telling us it
   // parsed.
   ASSERT(decoder.BytesParsed() <= ofs);
@@ -491,7 +483,7 @@ void CheckBytesParsed(const upb::pb::Decoder& decoder, size_t ofs) {
 }
 
 static bool parse(VerboseParserEnvironment* env,
-                  const upb::pb::Decoder& decoder, int bytes) {
+                  upb::pb::DecoderPtr decoder, int bytes) {
   CheckBytesParsed(decoder, env->ofs());
   bool ret = env->ParseBuffer(bytes);
   if (ret) {
@@ -501,11 +493,11 @@ static bool parse(VerboseParserEnvironment* env,
   return ret;
 }
 
-void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
+void do_run_decoder(VerboseParserEnvironment* env, upb::pb::DecoderPtr decoder,
                     const string& proto, const string* expected_output,
                     size_t i, size_t j, bool may_skip) {
   env->Reset(proto.c_str(), proto.size(), may_skip, expected_output == NULL);
-  decoder->Reset();
+  decoder.Reset();
 
   testhash = Hash(proto, expected_output, i, j, may_skip);
   if (filter_hash && testhash != filter_hash) return;
@@ -515,7 +507,7 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
     if (filter_hash) {
       fprintf(stderr, "RUNNING TEST CASE, hash=%x\n", testhash);
       fprintf(stderr, "JIT on: %s\n",
-              global_method->is_native() ? "true" : "false");
+              global_method.is_native() ? "true" : "false");
       fprintf(stderr, "Input (len=%u): ", (unsigned)proto.size());
       PrintBinary(proto);
       fprintf(stderr, "\n");
@@ -534,9 +526,9 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
     }
 
     bool ok = env->Start() &&
-              parse(env, *decoder, i) &&
-              parse(env, *decoder, j - i) &&
-              parse(env, *decoder, -1) &&
+              parse(env, decoder, i) &&
+              parse(env, decoder, j - i) &&
+              parse(env, decoder, -1) &&
               env->End();
 
     ASSERT(env->CheckConsistency());
@@ -564,8 +556,8 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
 void run_decoder(const string& proto, const string* expected_output) {
   VerboseParserEnvironment env(filter_hash != 0);
   upb::Sink sink(global_handlers, &closures[0]);
-  upb::pb::Decoder *decoder = CreateDecoder(env.env(), global_method, &sink);
-  env.ResetBytesSink(decoder->input());
+  upb::pb::DecoderPtr decoder = CreateDecoder(env.env(), global_method, sink);
+  env.ResetBytesSink(decoder.input());
   for (size_t i = 0; i < proto.size(); i++) {
     for (size_t j = i; j < UPB_MIN(proto.size(), i + 5); j++) {
       do_run_decoder(&env, decoder, proto, expected_output, i, j, true);
@@ -883,9 +875,9 @@ void test_valid() {
     upb::Environment env;
     env.ReportErrorsTo(&status);
     upb::Sink sink(global_handlers, &closures[0]);
-    upb::pb::Decoder* decoder = CreateDecoder(&env, global_method, &sink);
+    upb::pb::DecoderPtr decoder = CreateDecoder(&env, global_method, sink);
     output.clear();
-    bool ok = upb::BufferSource::PutBuffer("", 0, decoder->input());
+    bool ok = upb::PutBuffer(std::string(), decoder.input());
     ASSERT(ok);
     ASSERT(status.ok());
     if (test_mode == ALL_HANDLERS) {
@@ -1133,23 +1125,22 @@ void test_valid() {
   run_decoder(buf, &textbuf);
 }
 
-upb::reffed_ptr<const upb::pb::DecoderMethod> NewMethod(
-    const upb::Handlers* dest_handlers, bool allow_jit) {
-  upb::pb::CodeCache cache;
-  cache.set_allow_jit(allow_jit);
-  return cache.GetDecoderMethod(upb::pb::DecoderMethodOptions(dest_handlers));
-}
+void empty_callback(const void *closure, upb::Handlers* h_ptr) {}
 
 void test_emptyhandlers(upb::SymbolTable* symtab, bool allowjit) {
   // Create an empty handlers to make sure that the decoder can handle empty
   // messages.
-  const upb::MessageDef* md = Empty_getmsgdef(symtab);
-  upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(md));
-  bool ok = h->Freeze(NULL);
-  ASSERT(ok);
-upb::reffed_ptr<const upb::pb::DecoderMethod> method =
-      NewMethod(h.get(), allowjit);
-  ASSERT(method.get());
+  HandlerRegisterData handlerdata;
+  handlerdata.mode = test_mode;
+
+  upb::HandlerCache handler_cache(empty_callback, &handlerdata);
+  upb::pb::CodeCache pb_code_cache(&handler_cache);
+
+  pb_code_cache.set_allow_jit(allowjit);
+
+  upb::MessageDefPtr md = upb::MessageDefPtr(Empty_getmsgdef(symtab->ptr()));
+  global_handlers = handler_cache.Get(md);
+  global_method = pb_code_cache.Get(md);
 
   // TODO: also test the case where a message has fields, but the fields are
   // submessage fields and have no handlers. This also results in a decoder
@@ -1169,9 +1160,9 @@ upb::reffed_ptr<const upb::pb::DecoderMethod> method =
   };
   for (int i = 0; testdata[i].data; i++) {
     VerboseParserEnvironment env(filter_hash != 0);
-    upb::Sink sink(method->dest_handlers(), &closures[0]);
-    upb::pb::Decoder* decoder = CreateDecoder(env.env(), method.get(), &sink);
-    env.ResetBytesSink(decoder->input());
+    upb::Sink sink(global_method.dest_handlers(), &closures[0]);
+    upb::pb::DecoderPtr decoder = CreateDecoder(env.env(), global_method, sink);
+    env.ResetBytesSink(decoder.input());
     env.Reset(testdata[i].data, testdata[i].length, true, false);
     ASSERT(env.Start());
     ASSERT(env.ParseBuffer(-1));
@@ -1181,24 +1172,25 @@ upb::reffed_ptr<const upb::pb::DecoderMethod> method =
 }
 
 void run_tests(bool use_jit) {
-  upb::reffed_ptr<const upb::pb::DecoderMethod> method;
-  upb::reffed_ptr<const upb::Handlers> handlers;
-  upb::SymbolTable* symtab = upb::SymbolTable::New();
+  HandlerRegisterData handlerdata;
+  handlerdata.mode = test_mode;
 
-  handlers = NewHandlers(symtab, test_mode);
-  global_handlers = handlers.get();
+  upb::SymbolTable symtab;
+  upb::HandlerCache handler_cache(callback, &handlerdata);
+  upb::pb::CodeCache pb_code_cache(&handler_cache);
 
-  method = NewMethod(handlers.get(), use_jit);
-  global_method = method.get();
-  ASSERT(use_jit == global_method->is_native());
+  pb_code_cache.set_allow_jit(use_jit);
+
+  upb::MessageDefPtr md(DecoderTest_getmsgdef(symtab.ptr()));
+  global_handlers = handler_cache.Get(md);
+  global_method = pb_code_cache.Get(md);
+  ASSERT(use_jit == global_method.is_native());
   completed = 0;
 
   test_invalid();
   test_valid();
 
-  test_emptyhandlers(symtab, use_jit);
-
-  upb::SymbolTable::Free(symtab);
+  test_emptyhandlers(&symtab, use_jit);
 }
 
 void run_test_suite() {
@@ -1218,9 +1210,6 @@ int run_tests(int argc, char *argv[]) {
     closures[i] = i;
   }
 
-  upb::reffed_ptr<const upb::pb::DecoderMethod> method;
-  upb::reffed_ptr<const upb::Handlers> handlers;
-
   // Count tests.
   count = &total;
   total = 0;
diff --git a/tests/test_handlers.c b/tests/test_handlers.c
deleted file mode 100644
index 2b19cab..0000000
--- a/tests/test_handlers.c
+++ /dev/null
@@ -1,42 +0,0 @@
-
-#include <stdlib.h>
-#include <string.h>
-#include "google/protobuf/descriptor.upbdefs.h"
-#include "upb/handlers.h"
-#include "upb_test.h"
-
-static bool startmsg(void *c, const void *hd) {
-  UPB_UNUSED(c);
-  UPB_UNUSED(hd);
-  return true;
-}
-
-static void test_error() {
-  /* Test creating handlers of a static msgdef. */
-  upb_symtab *s = upb_symtab_new();
-  const upb_msgdef *m = google_protobuf_DescriptorProto_getmsgdef(s);
-  upb_handlers *h = upb_handlers_new(m, &h);
-
-  /* Attempt to set the same handler twice causes error. */
-  ASSERT(upb_ok(upb_handlers_status(h)));
-  upb_handlers_setstartmsg(h, &startmsg, NULL);
-  ASSERT(upb_ok(upb_handlers_status(h)));
-  upb_handlers_setstartmsg(h, &startmsg, NULL);
-  ASSERT(!upb_ok(upb_handlers_status(h)));
-  ASSERT(!upb_handlers_freeze(&h, 1, NULL));
-
-  /* Clearing the error will let us proceed. */
-  upb_handlers_clearerr(h);
-  ASSERT(upb_handlers_freeze(&h, 1, NULL));
-  ASSERT(upb_handlers_isfrozen(h));
-
-  upb_handlers_unref(h, &h);
-  upb_symtab_free(s);
-}
-
-int run_tests(int argc, char *argv[]) {
-  UPB_UNUSED(argc);
-  UPB_UNUSED(argv);
-  test_error();
-  return 0;
-}
diff --git a/tests/test_util.h b/tests/test_util.h
index 1b1ff01..0b5ddd4 100644
--- a/tests/test_util.h
+++ b/tests/test_util.h
@@ -78,14 +78,14 @@ class VerboseParserEnvironment {
     if (verbose_) {
       fprintf(stderr, "Calling start()\n");
     }
-    return sink_->Start(len_, &subc_);
+    return sink_.Start(len_, &subc_);
   }
 
   bool End() {
     if (verbose_) {
       fprintf(stderr, "Calling end()\n");
     }
-    end_ok_ = sink_->End();
+    end_ok_ = sink_.End();
     end_ok_set_ = true;
 
     return end_ok_;
@@ -137,7 +137,7 @@ class VerboseParserEnvironment {
               (unsigned)bytes, (unsigned)ofs_, (unsigned)(ofs_ + bytes));
     }
 
-    int parsed = sink_->PutBuffer(subc_, buf2, bytes, &global_handle);
+    int parsed = sink_.PutBuffer(subc_, buf2, bytes, &global_handle);
     free(buf2);
 
     if (verbose_) {
@@ -170,7 +170,7 @@ class VerboseParserEnvironment {
     return true;
   }
 
-  void ResetBytesSink(upb::BytesSink* sink) {
+  void ResetBytesSink(upb::BytesSink sink) {
     sink_ = sink;
   }
 
@@ -181,7 +181,7 @@ class VerboseParserEnvironment {
 
  private:
   upb::Environment env_;
-  upb::BytesSink* sink_;
+  upb::BytesSink sink_;
   const char* buf_;
   size_t len_;
   bool verbose_;
diff --git a/upb/bindings/stdc++/string.h b/upb/bindings/stdc++/string.h
index 4d7a719..55b44cf 100644
--- a/upb/bindings/stdc++/string.h
+++ b/upb/bindings/stdc++/string.h
@@ -48,11 +48,12 @@ class StringSink {
   explicit StringSink(T* target) {
     // TODO(haberman): we need to avoid rebuilding a new handler every time,
     // but with class globals disallowed for google3 C++ this is tricky.
+    upb_byteshandler_init(&handler_);
     FillStringHandler<T>::SetHandler(&handler_);
     input_.Reset(&handler_, target);
   }
 
-  BytesSink* input() { return &input_; }
+  BytesSink input() { return input_; }
 
  private:
   upb_byteshandler handler_;
diff --git a/upb/handlers-inl.h b/upb/handlers-inl.h
index b038e30..5677a4a 100644
--- a/upb/handlers-inl.h
+++ b/upb/handlers-inl.h
@@ -858,7 +858,7 @@ inline Handler<T>::Handler(F func)
     : registered_(false),
       cleanup_data_(func.GetData()),
       cleanup_func_(func.GetCleanup()) {
-  upb_handlerattr_sethandlerdata(&attr_, func.GetData());
+  attr_.handler_data = func.GetData();
   typedef typename ReturnOf<T>::Return Return;
   typedef typename ConvertParams<F, T>::Func ConvertedParamsFunc;
   typedef typename MaybeWrapReturn<ConvertedParamsFunc, Return>::Func
diff --git a/upb/handlers.c b/upb/handlers.c
index fd81b03..ba27b98 100644
--- a/upb/handlers.c
+++ b/upb/handlers.c
@@ -286,6 +286,10 @@ const upb_handlers *upb_handlers_getsubhandlers_sel(const upb_handlers *h,
 
 const upb_msgdef *upb_handlers_msgdef(const upb_handlers *h) { return h->msg; }
 
+bool upb_handlers_addcleanup(upb_handlers *h, void *p, upb_handlerfree *func) {
+  return upb_handlercache_addcleanup(h->cache, p, func);
+}
+
 upb_handlertype_t upb_handlers_getprimitivehandlertype(const upb_fielddef *f) {
   switch (upb_fielddef_type(f)) {
     case UPB_TYPE_INT32:
@@ -470,12 +474,13 @@ void upb_handlercache_free(upb_handlercache *cache) {
   upb_gfree(cache);
 }
 
-bool upb_handlers_addcleanup(upb_handlers *h, void *p, upb_handlerfree *func) {
+bool upb_handlercache_addcleanup(upb_handlercache *c, void *p,
+                                 upb_handlerfree *func) {
   bool ok;
-  if (upb_inttable_lookupptr(&h->cache->cleanup_, p, NULL)) {
+  if (upb_inttable_lookupptr(&c->cleanup_, p, NULL)) {
     return false;
   }
-  ok = upb_inttable_insertptr(&h->cache->cleanup_, p, upb_value_fptr(func));
+  ok = upb_inttable_insertptr(&c->cleanup_, p, upb_value_fptr(func));
   UPB_ASSERT(ok);
   return true;
 }
diff --git a/upb/handlers.h b/upb/handlers.h
index 4558786..44cad18 100644
--- a/upb/handlers.h
+++ b/upb/handlers.h
@@ -602,6 +602,8 @@ upb_handlercache *upb_handlercache_new(upb_handlers_callback *callback,
 void upb_handlercache_free(upb_handlercache *cache);
 const upb_handlers *upb_handlercache_get(upb_handlercache *cache,
                                          const upb_msgdef *md);
+bool upb_handlercache_addcleanup(upb_handlercache *h, void *p,
+                                 upb_handlerfree *hfree);
 
 UPB_END_EXTERN_C
 
diff --git a/upb/json/parser.c b/upb/json/parser.c
index 4bc9163..1dac800 100644
--- a/upb/json/parser.c
+++ b/upb/json/parser.c
@@ -301,13 +301,13 @@ 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->env, 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->sink, p->ignore_json_unknown);
+                                         frame->sink, p->ignore_json_unknown);
 }
 
 static void json_parser_any_frame_free(upb_jsonparser_any_frame *frame) {
@@ -383,9 +383,12 @@ static bool check_stack(upb_json_parser *p) {
 static void set_name_table(upb_json_parser *p, upb_jsonparser_frame *frame) {
   upb_value v;
   const upb_json_codecache *cache = p->method->cache;
-  bool ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
-  const upb_json_parsermethod *method = upb_value_getptr(v);
+  bool ok;
+  const upb_json_parsermethod *method;
+
+  ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
   UPB_ASSERT(ok);
+  method = upb_value_getconstptr(v);
 
   frame->name_table = &method->name_table;
 }
@@ -1287,7 +1290,7 @@ static bool end_any_stringval(upb_json_parser *p) {
     }
 
     json_parser_any_frame_set_payload_type(p, p->top->any_frame, payload_type);
-    
+
     return true;
   } else {
     upb_status_seterrf(
@@ -2416,11 +2419,11 @@ static bool is_string_wrapper_object(upb_json_parser *p) {
  * final state once, when the closing '"' is seen. */
 
 
-#line 2578 "upb/json/parser.rl"
+#line 2581 "upb/json/parser.rl"
 
 
 
-#line 2424 "upb/json/parser.c"
+#line 2427 "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, 
@@ -2667,7 +2670,7 @@ static const int json_en_value_machine = 75;
 static const int json_en_main = 1;
 
 
-#line 2581 "upb/json/parser.rl"
+#line 2584 "upb/json/parser.rl"
 
 size_t parse(void *closure, const void *hd, const char *buf, size_t size,
              const upb_bufhandle *handle) {
@@ -2690,7 +2693,7 @@ size_t parse(void *closure, const void *hd, const char *buf, size_t size,
   capture_resume(parser, buf);
 
   
-#line 2694 "upb/json/parser.c"
+#line 2697 "upb/json/parser.c"
 	{
 	int _klen;
 	unsigned int _trans;
@@ -2765,83 +2768,83 @@ _match:
 		switch ( *_acts++ )
 		{
 	case 1:
-#line 2429 "upb/json/parser.rl"
+#line 2432 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 2:
-#line 2431 "upb/json/parser.rl"
+#line 2434 "upb/json/parser.rl"
 	{ p--; {stack[top++] = cs; cs = 23;goto _again;} }
 	break;
 	case 3:
-#line 2435 "upb/json/parser.rl"
+#line 2438 "upb/json/parser.rl"
 	{ start_text(parser, p); }
 	break;
 	case 4:
-#line 2436 "upb/json/parser.rl"
+#line 2439 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_text(parser, p)); }
 	break;
 	case 5:
-#line 2442 "upb/json/parser.rl"
+#line 2445 "upb/json/parser.rl"
 	{ start_hex(parser); }
 	break;
 	case 6:
-#line 2443 "upb/json/parser.rl"
+#line 2446 "upb/json/parser.rl"
 	{ hexdigit(parser, p); }
 	break;
 	case 7:
-#line 2444 "upb/json/parser.rl"
+#line 2447 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_hex(parser)); }
 	break;
 	case 8:
-#line 2450 "upb/json/parser.rl"
+#line 2453 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(escape(parser, p)); }
 	break;
 	case 9:
-#line 2456 "upb/json/parser.rl"
+#line 2459 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 10:
-#line 2468 "upb/json/parser.rl"
+#line 2471 "upb/json/parser.rl"
 	{ start_duration_base(parser, p); }
 	break;
 	case 11:
-#line 2469 "upb/json/parser.rl"
+#line 2472 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_duration_base(parser, p)); }
 	break;
 	case 12:
-#line 2471 "upb/json/parser.rl"
+#line 2474 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 13:
-#line 2476 "upb/json/parser.rl"
+#line 2479 "upb/json/parser.rl"
 	{ start_timestamp_base(parser, p); }
 	break;
 	case 14:
-#line 2477 "upb/json/parser.rl"
+#line 2480 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_timestamp_base(parser, p)); }
 	break;
 	case 15:
-#line 2479 "upb/json/parser.rl"
+#line 2482 "upb/json/parser.rl"
 	{ start_timestamp_fraction(parser, p); }
 	break;
 	case 16:
-#line 2480 "upb/json/parser.rl"
+#line 2483 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_timestamp_fraction(parser, p)); }
 	break;
 	case 17:
-#line 2482 "upb/json/parser.rl"
+#line 2485 "upb/json/parser.rl"
 	{ start_timestamp_zone(parser, p); }
 	break;
 	case 18:
-#line 2483 "upb/json/parser.rl"
+#line 2486 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_timestamp_zone(parser, p)); }
 	break;
 	case 19:
-#line 2485 "upb/json/parser.rl"
+#line 2488 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
 	case 20:
-#line 2490 "upb/json/parser.rl"
+#line 2493 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_TIMESTAMP)) {
           {stack[top++] = cs; cs = 47;goto _again;}
@@ -2853,11 +2856,11 @@ _match:
       }
 	break;
 	case 21:
-#line 2501 "upb/json/parser.rl"
+#line 2504 "upb/json/parser.rl"
 	{ p--; {stack[top++] = cs; cs = 75;goto _again;} }
 	break;
 	case 22:
-#line 2506 "upb/json/parser.rl"
+#line 2509 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           start_any_member(parser, p);
@@ -2867,11 +2870,11 @@ _match:
       }
 	break;
 	case 23:
-#line 2513 "upb/json/parser.rl"
+#line 2516 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_membername(parser)); }
 	break;
 	case 24:
-#line 2516 "upb/json/parser.rl"
+#line 2519 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           end_any_member(parser, p);
@@ -2881,7 +2884,7 @@ _match:
       }
 	break;
 	case 25:
-#line 2527 "upb/json/parser.rl"
+#line 2530 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           start_any_object(parser, p);
@@ -2891,7 +2894,7 @@ _match:
       }
 	break;
 	case 26:
-#line 2536 "upb/json/parser.rl"
+#line 2539 "upb/json/parser.rl"
 	{
         if (is_wellknown_msg(parser, UPB_WELLKNOWN_ANY)) {
           CHECK_RETURN_TOP(end_any_object(parser, p));
@@ -2901,54 +2904,54 @@ _match:
       }
 	break;
 	case 27:
-#line 2548 "upb/json/parser.rl"
+#line 2551 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_array(parser)); }
 	break;
 	case 28:
-#line 2552 "upb/json/parser.rl"
+#line 2555 "upb/json/parser.rl"
 	{ end_array(parser); }
 	break;
 	case 29:
-#line 2557 "upb/json/parser.rl"
+#line 2560 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_number(parser, p)); }
 	break;
 	case 30:
-#line 2558 "upb/json/parser.rl"
+#line 2561 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_number(parser, p)); }
 	break;
 	case 31:
-#line 2560 "upb/json/parser.rl"
+#line 2563 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_stringval(parser)); }
 	break;
 	case 32:
-#line 2561 "upb/json/parser.rl"
+#line 2564 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_stringval(parser)); }
 	break;
 	case 33:
-#line 2563 "upb/json/parser.rl"
+#line 2566 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, true)); }
 	break;
 	case 34:
-#line 2565 "upb/json/parser.rl"
+#line 2568 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, false)); }
 	break;
 	case 35:
-#line 2567 "upb/json/parser.rl"
+#line 2570 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_null(parser)); }
 	break;
 	case 36:
-#line 2569 "upb/json/parser.rl"
+#line 2572 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(start_subobject_full(parser)); }
 	break;
 	case 37:
-#line 2570 "upb/json/parser.rl"
+#line 2573 "upb/json/parser.rl"
 	{ end_subobject_full(parser); }
 	break;
 	case 38:
-#line 2575 "upb/json/parser.rl"
+#line 2578 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; goto _again;} }
 	break;
-#line 2952 "upb/json/parser.c"
+#line 2955 "upb/json/parser.c"
 		}
 	}
 
@@ -2965,32 +2968,32 @@ _again:
 	while ( __nacts-- > 0 ) {
 		switch ( *__acts++ ) {
 	case 0:
-#line 2427 "upb/json/parser.rl"
+#line 2430 "upb/json/parser.rl"
 	{ p--; {cs = stack[--top]; 	if ( p == pe )
 		goto _test_eof;
 goto _again;} }
 	break;
 	case 30:
-#line 2558 "upb/json/parser.rl"
+#line 2561 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_number(parser, p)); }
 	break;
 	case 33:
-#line 2563 "upb/json/parser.rl"
+#line 2566 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, true)); }
 	break;
 	case 34:
-#line 2565 "upb/json/parser.rl"
+#line 2568 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_bool(parser, false)); }
 	break;
 	case 35:
-#line 2567 "upb/json/parser.rl"
+#line 2570 "upb/json/parser.rl"
 	{ CHECK_RETURN_TOP(end_null(parser)); }
 	break;
 	case 37:
-#line 2570 "upb/json/parser.rl"
+#line 2573 "upb/json/parser.rl"
 	{ end_subobject_full(parser); }
 	break;
-#line 2994 "upb/json/parser.c"
+#line 2997 "upb/json/parser.c"
 		}
 	}
 	}
@@ -2998,7 +3001,7 @@ goto _again;} }
 	_out: {}
 	}
 
-#line 2603 "upb/json/parser.rl"
+#line 2606 "upb/json/parser.rl"
 
   if (p != pe) {
     upb_status_seterrf(&parser->status, "Parse error at '%.*s'\n", pe - p, p);
@@ -3046,13 +3049,13 @@ static void json_parser_reset(upb_json_parser *p) {
 
   /* Emit Ragel initialization of the parser. */
   
-#line 3050 "upb/json/parser.c"
+#line 3053 "upb/json/parser.c"
 	{
 	cs = json_start;
 	top = 0;
 	}
 
-#line 2650 "upb/json/parser.rl"
+#line 2653 "upb/json/parser.rl"
   p->current_state = cs;
   p->parser_top = top;
   accumulate_clear(p);
@@ -3067,7 +3070,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
   upb_msg_field_iter i;
   upb_alloc *alloc = upb_arena_alloc(&c->arena);
 
-  upb_json_parsermethod *m = upb_gmalloc(sizeof(*m));
+  upb_json_parsermethod *m = upb_malloc(alloc, sizeof(*m));
 
   m->cache = c;
 
@@ -3090,7 +3093,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
     size_t len = upb_fielddef_getjsonname(f, NULL, 0);
     buf = upb_malloc(alloc, len);
     upb_fielddef_getjsonname(f, buf, len);
-    upb_strtable_insert3(&m->name_table, buf, len, v, alloc);
+    upb_strtable_insert3(&m->name_table, buf, strlen(buf), v, alloc);
 
     if (strcmp(buf, upb_fielddef_name(f)) != 0) {
       /* Since the JSON name is different from the regular field name, add an
@@ -3109,7 +3112,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
 upb_json_parser *upb_json_parser_create(upb_env *env,
                                         const upb_json_parsermethod *method,
                                         const upb_symtab* symtab,
-                                        upb_sink *output,
+                                        upb_sink output,
                                         bool ignore_json_unknown) {
 #ifndef NDEBUG
   const size_t size_before = upb_env_bytesallocated(env);
@@ -3125,8 +3128,8 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   upb_bytessink_reset(&p->input_, &method->input_handler_, p);
 
   json_parser_reset(p);
-  upb_sink_reset(&p->top->sink, output->handlers, output->closure);
-  p->top->m = upb_handlers_msgdef(output->handlers);
+  p->top->sink = output;
+  p->top->m = upb_handlers_msgdef(output.handlers);
   if (is_wellknown_msg(p, UPB_WELLKNOWN_ANY)) {
     p->top->is_any = true;
     p->top->any_frame = json_parser_any_frame_new(p);
@@ -3146,8 +3149,8 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   return p;
 }
 
-upb_bytessink *upb_json_parser_input(upb_json_parser *p) {
-  return &p->input_;
+upb_bytessink upb_json_parser_input(upb_json_parser *p) {
+  return p->input_;
 }
 
 const upb_byteshandler *upb_json_parsermethod_inputhandler(
@@ -3174,21 +3177,22 @@ void upb_json_codecache_free(upb_json_codecache *c) {
   upb_gfree(c);
 }
 
-upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
-                                              const upb_msgdef *md) {
+const upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
+                                                    const upb_msgdef *md) {
   upb_json_parsermethod *m;
   upb_value v;
   upb_msg_field_iter i;
+  upb_alloc *alloc = upb_arena_alloc(&c->arena);
 
   if (upb_inttable_lookupptr(&c->methods, md, &v)) {
-    return upb_value_getptr(v);
+    return upb_value_getconstptr(v);
   }
 
   m = parsermethod_new(c, md);
-  v = upb_value_ptr(m);
+  v = upb_value_constptr(m);
 
   if (!m) return NULL;
-  if (!upb_inttable_insertptr(&c->methods, m, v)) return NULL;
+  if (!upb_inttable_insertptr2(&c->methods, md, v, alloc)) return NULL;
 
   /* Populate parser methods for all submessages, so the name tables will
    * be available during parsing. */
diff --git a/upb/json/parser.h b/upb/json/parser.h
index d5ec396..d1a1471 100644
--- a/upb/json/parser.h
+++ b/upb/json/parser.h
@@ -14,17 +14,44 @@
 namespace upb {
 namespace json {
 class CodeCache;
-class Parser;
-class ParserMethod;
+class ParserPtr;
+class ParserMethodPtr;
 }  /* namespace json */
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::json::Parser, upb_json_parser)
-UPB_DECLARE_TYPE(upb::json::ParserMethod, upb_json_parsermethod)
-UPB_DECLARE_TYPE(upb::json::CodeCache, upb_json_codecache)
+/* upb_json_parsermethod ******************************************************/
 
-/* upb::json::Parser **********************************************************/
+struct upb_json_parsermethod;
+typedef struct upb_json_parsermethod upb_json_parsermethod;
+
+UPB_BEGIN_EXTERN_C
+
+const upb_byteshandler* upb_json_parsermethod_inputhandler(
+    const upb_json_parsermethod* m);
+
+UPB_END_EXTERN_C
+
+#ifdef __cplusplus
+
+class upb::json::ParserMethodPtr {
+ public:
+  ParserMethodPtr() : ptr_(nullptr) {}
+  ParserMethodPtr(const upb_json_parsermethod* ptr) : ptr_(ptr) {}
+
+  const upb_json_parsermethod* ptr() const { return ptr_; }
+
+  const BytesHandler* input_handler() const {
+    return upb_json_parsermethod_inputhandler(ptr());
+  }
+
+ private:
+  const upb_json_parsermethod* ptr_;
+};
+
+#endif  /* __cplusplus */
+
+/* upb_json_parser ************************************************************/
 
 /* Preallocation hint: parser won't allocate more bytes than this when first
  * constructed.  This hint may be an overestimate for some build configurations.
@@ -32,89 +59,72 @@ UPB_DECLARE_TYPE(upb::json::CodeCache, upb_json_codecache)
  * it may be an underestimate. */
 #define UPB_JSON_PARSER_SIZE 5712
 
+struct upb_json_parser;
+typedef struct upb_json_parser upb_json_parser;
+
+UPB_BEGIN_EXTERN_C
+
+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_bytessink upb_json_parser_input(upb_json_parser* p);
+
+UPB_END_EXTERN_C
+
 #ifdef __cplusplus
 
 /* Parses an incoming BytesStream, pushing the results to the destination
  * sink. */
-class upb::json::Parser {
+class upb::json::ParserPtr {
  public:
-  static Parser* Create(Environment* env, const ParserMethod* method,
-                        const SymbolTable* symtab,
-                        Sink* output, bool ignore_json_unknown);
+  ParserPtr(upb_json_parser* ptr) : ptr_(ptr) {}
 
-  BytesSink* input();
+  static ParserPtr Create(Environment* env, 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));
+  }
 
- private:
-  UPB_DISALLOW_POD_OPS(Parser, upb::json::Parser)
-};
-
-class upb::json::ParserMethod {
- public:
-  /* The input handlers for this decoder method. */
-  const BytesHandler* input_handler() const;
+  BytesSink input() { return upb_json_parser_input(ptr_); }
 
  private:
-  UPB_DISALLOW_POD_OPS(ParserMethod, upb::json::ParserMethod)
+  upb_json_parser* ptr_;
 };
 
-class upb::json::CodeCache {
- public:
-  static CodeCache* New();
-  static void Free(CodeCache* cache);
-
-  /* Returns a DecoderMethod that can push data to the given handlers.
-   * If a suitable method already exists, it will be returned from the cache. */
-  const ParserMethod *Get(const MessageDef* md);
+#endif  /* __cplusplus */
 
- private:
-  UPB_DISALLOW_POD_OPS(CodeCache, upb::json::CodeCache)
-};
+/* upb_json_codecache *********************************************************/
 
-#endif
+struct upb_json_codecache;
+typedef struct upb_json_codecache upb_json_codecache;
 
 UPB_BEGIN_EXTERN_C
 
-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_bytessink *upb_json_parser_input(upb_json_parser *p);
-
-const upb_byteshandler *upb_json_parsermethod_inputhandler(
-    const upb_json_parsermethod *m);
-
 upb_json_codecache *upb_json_codecache_new();
 void upb_json_codecache_free(upb_json_codecache *cache);
-upb_json_parsermethod* upb_json_codecache_get(upb_json_codecache* cache,
-                                              const upb_msgdef* md);
+const upb_json_parsermethod* upb_json_codecache_get(upb_json_codecache* cache,
+                                                    const upb_msgdef* md);
 
 UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
-namespace upb {
-namespace json {
-inline Parser* Parser::Create(Environment* env, const ParserMethod* method,
-                              const SymbolTable* symtab,
-                              Sink* output, bool ignore_json_unknown) {
-  return upb_json_parser_create(
-      env, method, symtab, output, ignore_json_unknown);
-}
-inline BytesSink* Parser::input() {
-  return upb_json_parser_input(this);
-}
-
-inline const BytesHandler* ParserMethod::input_handler() const {
-  return upb_json_parsermethod_inputhandler(this);
-}
-/* static */
-inline const ParserMethod* CodeCache::Get(const MessageDef* md) {
-  return upb_json_codecache_get(this, md);
-}
+class upb::json::CodeCache {
+ public:
+  CodeCache() : ptr_(upb_json_codecache_new(), upb_json_codecache_free) {}
 
-}  /* namespace json */
-}  /* namespace upb */
+  /* Returns a DecoderMethod that can push data to the given handlers.
+   * If a suitable method already exists, it will be returned from the cache. */
+  ParserMethodPtr Get(MessageDefPtr md) {
+    return upb_json_codecache_get(ptr_.get(), md.ptr());
+  }
+
+ private:
+  std::unique_ptr<upb_json_codecache, decltype(&upb_json_codecache_free)> ptr_;
+};
 
 #endif
 
diff --git a/upb/json/parser.rl b/upb/json/parser.rl
index c2866c9..05a9505 100644
--- a/upb/json/parser.rl
+++ b/upb/json/parser.rl
@@ -299,13 +299,13 @@ 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->env, 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->sink, p->ignore_json_unknown);
+                                         frame->sink, p->ignore_json_unknown);
 }
 
 static void json_parser_any_frame_free(upb_jsonparser_any_frame *frame) {
@@ -381,9 +381,12 @@ static bool check_stack(upb_json_parser *p) {
 static void set_name_table(upb_json_parser *p, upb_jsonparser_frame *frame) {
   upb_value v;
   const upb_json_codecache *cache = p->method->cache;
-  bool ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
-  const upb_json_parsermethod *method = upb_value_getptr(v);
+  bool ok;
+  const upb_json_parsermethod *method;
+
+  ok = upb_inttable_lookupptr(&cache->methods, frame->m, &v);
   UPB_ASSERT(ok);
+  method = upb_value_getconstptr(v);
 
   frame->name_table = &method->name_table;
 }
@@ -1285,7 +1288,7 @@ static bool end_any_stringval(upb_json_parser *p) {
     }
 
     json_parser_any_frame_set_payload_type(p, p->top->any_frame, payload_type);
-    
+
     return true;
   } else {
     upb_status_seterrf(
@@ -2661,7 +2664,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
   upb_msg_field_iter i;
   upb_alloc *alloc = upb_arena_alloc(&c->arena);
 
-  upb_json_parsermethod *m = upb_gmalloc(sizeof(*m));
+  upb_json_parsermethod *m = upb_malloc(alloc, sizeof(*m));
 
   m->cache = c;
 
@@ -2684,7 +2687,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
     size_t len = upb_fielddef_getjsonname(f, NULL, 0);
     buf = upb_malloc(alloc, len);
     upb_fielddef_getjsonname(f, buf, len);
-    upb_strtable_insert3(&m->name_table, buf, len, v, alloc);
+    upb_strtable_insert3(&m->name_table, buf, strlen(buf), v, alloc);
 
     if (strcmp(buf, upb_fielddef_name(f)) != 0) {
       /* Since the JSON name is different from the regular field name, add an
@@ -2703,7 +2706,7 @@ static upb_json_parsermethod *parsermethod_new(upb_json_codecache *c,
 upb_json_parser *upb_json_parser_create(upb_env *env,
                                         const upb_json_parsermethod *method,
                                         const upb_symtab* symtab,
-                                        upb_sink *output,
+                                        upb_sink output,
                                         bool ignore_json_unknown) {
 #ifndef NDEBUG
   const size_t size_before = upb_env_bytesallocated(env);
@@ -2719,8 +2722,8 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   upb_bytessink_reset(&p->input_, &method->input_handler_, p);
 
   json_parser_reset(p);
-  upb_sink_reset(&p->top->sink, output->handlers, output->closure);
-  p->top->m = upb_handlers_msgdef(output->handlers);
+  p->top->sink = output;
+  p->top->m = upb_handlers_msgdef(output.handlers);
   if (is_wellknown_msg(p, UPB_WELLKNOWN_ANY)) {
     p->top->is_any = true;
     p->top->any_frame = json_parser_any_frame_new(p);
@@ -2740,8 +2743,8 @@ upb_json_parser *upb_json_parser_create(upb_env *env,
   return p;
 }
 
-upb_bytessink *upb_json_parser_input(upb_json_parser *p) {
-  return &p->input_;
+upb_bytessink upb_json_parser_input(upb_json_parser *p) {
+  return p->input_;
 }
 
 const upb_byteshandler *upb_json_parsermethod_inputhandler(
@@ -2768,21 +2771,22 @@ void upb_json_codecache_free(upb_json_codecache *c) {
   upb_gfree(c);
 }
 
-upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
-                                              const upb_msgdef *md) {
+const upb_json_parsermethod *upb_json_codecache_get(upb_json_codecache *c,
+                                                    const upb_msgdef *md) {
   upb_json_parsermethod *m;
   upb_value v;
   upb_msg_field_iter i;
+  upb_alloc *alloc = upb_arena_alloc(&c->arena);
 
   if (upb_inttable_lookupptr(&c->methods, md, &v)) {
-    return upb_value_getptr(v);
+    return upb_value_getconstptr(v);
   }
 
   m = parsermethod_new(c, md);
-  v = upb_value_ptr(m);
+  v = upb_value_constptr(m);
 
   if (!m) return NULL;
-  if (!upb_inttable_insertptr(&c->methods, m, v)) return NULL;
+  if (!upb_inttable_insertptr2(&c->methods, md, v, alloc)) return NULL;
 
   /* Populate parser methods for all submessages, so the name tables will
    * be available during parsing. */
diff --git a/upb/json/printer.c b/upb/json/printer.c
index b2c9ebd..83f1a58 100644
--- a/upb/json/printer.c
+++ b/upb/json/printer.c
@@ -13,7 +13,7 @@ struct upb_json_printer {
   upb_sink input_;
   /* BytesSink closure. */
   void *subc_;
-  upb_bytessink *output_;
+  upb_bytessink output_;
 
   /* We track the depth so that we know when to emit startstr/endstr on the
    * output. */
@@ -87,7 +87,7 @@ strpc *newstrpc_str(upb_handlers *h, const char * str) {
 static void print_data(
     upb_json_printer *p, const char *buf, unsigned int len) {
   /* TODO: Will need to change if we support pushback from the sink. */
-  size_t n = upb_bytessink_putbuf(p->output_, p->subc_, buf, len, NULL);
+  size_t n = upb_bytessink_putbuf(&p->output_, p->subc_, buf, len, NULL);
   UPB_ASSERT(n == len);
 }
 
@@ -369,7 +369,7 @@ static bool printer_startmsg(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(p->output_, 0, &p->subc_);
+    upb_bytessink_start(&p->output_, 0, &p->subc_);
   }
   start_frame(p);
   return true;
@@ -381,7 +381,7 @@ static bool printer_endmsg(void *closure, const void *handler_data, upb_status *
   UPB_UNUSED(s);
   end_frame(p);
   if (p->depth_ == 0) {
-    upb_bytessink_end(p->output_);
+    upb_bytessink_end(&p->output_);
   }
   return true;
 }
@@ -770,7 +770,7 @@ static bool printer_startdurationmsg(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(p->output_, 0, &p->subc_);
+    upb_bytessink_start(&p->output_, 0, &p->subc_);
   }
   return true;
 }
@@ -828,7 +828,7 @@ static bool printer_enddurationmsg(void *closure, const void *handler_data,
   print_data(p, "\"", 1);
 
   if (p->depth_ == 0) {
-    upb_bytessink_end(p->output_);
+    upb_bytessink_end(&p->output_);
   }
 
   UPB_UNUSED(handler_data);
@@ -839,7 +839,7 @@ static bool printer_starttimestampmsg(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(p->output_, 0, &p->subc_);
+    upb_bytessink_start(&p->output_, 0, &p->subc_);
   }
   return true;
 }
@@ -902,7 +902,7 @@ static bool printer_endtimestampmsg(void *closure, const void *handler_data,
   print_data(p, "\"", 1);
 
   if (p->depth_ == 0) {
-    upb_bytessink_end(p->output_);
+    upb_bytessink_end(&p->output_);
   }
 
   UPB_UNUSED(handler_data);
@@ -914,7 +914,7 @@ static bool printer_startmsg_noframe(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(p->output_, 0, &p->subc_);
+    upb_bytessink_start(&p->output_, 0, &p->subc_);
   }
   return true;
 }
@@ -925,7 +925,7 @@ static bool printer_endmsg_noframe(
   UPB_UNUSED(handler_data);
   UPB_UNUSED(s);
   if (p->depth_ == 0) {
-    upb_bytessink_end(p->output_);
+    upb_bytessink_end(&p->output_);
   }
   return true;
 }
@@ -1253,7 +1253,7 @@ 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_bytessink *output) {
+                                          upb_bytessink output) {
 #ifndef NDEBUG
   size_t size_before = upb_env_bytesallocated(e);
 #endif
@@ -1273,12 +1273,16 @@ upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
   return p;
 }
 
-upb_sink *upb_json_printer_input(upb_json_printer *p) {
-  return &p->input_;
+upb_sink upb_json_printer_input(upb_json_printer *p) {
+  return p->input_;
 }
 
 upb_handlercache *upb_json_printer_newcache(bool preserve_proto_fieldnames) {
   upb_json_printercache *cache = upb_gmalloc(sizeof(*cache));
+  upb_handlercache *ret = upb_handlercache_new(printer_sethandlers, cache);
+
   cache->preserve_fieldnames = preserve_proto_fieldnames;
-  return upb_handlercache_new(printer_sethandlers, cache);
+  upb_handlercache_addcleanup(ret, cache, upb_gfree);
+
+  return ret;
 }
diff --git a/upb/json/printer.h b/upb/json/printer.h
index fe9c8f1..a7a37bb 100644
--- a/upb/json/printer.h
+++ b/upb/json/printer.h
@@ -12,44 +12,24 @@
 #ifdef __cplusplus
 namespace upb {
 namespace json {
-class Printer;
+class PrinterPtr;
 }  /* namespace json */
 }  /* namespace upb */
 #endif
 
-UPB_DECLARE_TYPE(upb::json::Printer, upb_json_printer)
-
-
-/* upb::json::Printer *********************************************************/
+/* upb_json_printer ***********************************************************/
 
 #define UPB_JSON_PRINTER_SIZE 192
 
-#ifdef __cplusplus
-
-/* Prints an incoming stream of data to a BytesSink in JSON format. */
-class upb::json::Printer {
- public:
-  static Printer* Create(Environment* env, const upb::Handlers* handlers,
-                         BytesSink* output);
-
-  /* The input to the printer. */
-  Sink* input();
-
-  static const size_t kSize = UPB_JSON_PRINTER_SIZE;
-  static upb_handlercache* NewCache(bool preserve_proto_fieldnames);
-
- private:
-  UPB_DISALLOW_POD_OPS(Printer, upb::json::Printer)
-};
-
-#endif
+struct upb_json_printer;
+typedef struct upb_json_printer upb_json_printer;
 
 UPB_BEGIN_EXTERN_C
 
 /* Native C API. */
 upb_json_printer *upb_json_printer_create(upb_env *e, const upb_handlers *h,
-                                          upb_bytessink *output);
-upb_sink *upb_json_printer_input(upb_json_printer *p);
+                                          upb_bytessink output);
+upb_sink upb_json_printer_input(upb_json_printer *p);
 const upb_handlers *upb_json_printer_newhandlers(const upb_msgdef *md,
                                                  bool preserve_fieldnames,
                                                  const void *owner);
@@ -60,19 +40,29 @@ UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
-namespace upb {
-namespace json {
-inline Printer* Printer::Create(Environment* env, const upb::Handlers* handlers,
-                                BytesSink* output) {
-  return upb_json_printer_create(env, handlers, output);
-}
-inline Sink* Printer::input() { return upb_json_printer_input(this); }
-inline upb_handlercache* Printer::NewCache(bool preserve_proto_fieldnames) {
-  return upb_json_printer_newcache(preserve_proto_fieldnames);
-}
-}  /* namespace json */
-}  /* namespace upb */
+/* Prints an incoming stream of data to a BytesSink in JSON format. */
+class upb::json::PrinterPtr {
+ public:
+  PrinterPtr(upb_json_printer* ptr) : ptr_(ptr) {}
 
-#endif
+  static PrinterPtr Create(Environment *env, const upb::Handlers *handlers,
+                           BytesSink output) {
+    return PrinterPtr(upb_json_printer_create(env, handlers, output.sink()));
+  }
+
+  /* The input to the printer. */
+  Sink input() { return upb_json_printer_input(ptr_); }
+
+  static const size_t kSize = UPB_JSON_PRINTER_SIZE;
+
+  static HandlerCache NewCache(bool preserve_proto_fieldnames) {
+    return upb_json_printer_newcache(preserve_proto_fieldnames);
+  }
+
+ private:
+  upb_json_printer* ptr_;
+};
+
+#endif  /* __cplusplus */
 
 #endif  /* UPB_JSON_TYPED_PRINTER_H_ */
diff --git a/upb/pb/decoder.c b/upb/pb/decoder.c
index 0cae05b..cd64f72 100644
--- a/upb/pb/decoder.c
+++ b/upb/pb/decoder.c
@@ -993,7 +993,7 @@ void upb_pbdecoder_reset(upb_pbdecoder *d) {
 }
 
 upb_pbdecoder *upb_pbdecoder_create(upb_env *e, const upb_pbdecodermethod *m,
-                                    upb_sink *sink) {
+                                    upb_sink sink) {
   const size_t default_max_nesting = 64;
 #ifndef NDEBUG
   size_t size_before = upb_env_bytesallocated(e);
@@ -1017,12 +1017,11 @@ upb_pbdecoder *upb_pbdecoder_create(upb_env *e, const upb_pbdecodermethod *m,
   upb_pbdecoder_reset(d);
   upb_bytessink_reset(&d->input_, &m->input_handler_, d);
 
-  UPB_ASSERT(sink);
   if (d->method_->dest_handlers_) {
-    if (sink->handlers != d->method_->dest_handlers_)
+    if (sink.handlers != d->method_->dest_handlers_)
       return NULL;
   }
-  upb_sink_reset(&d->top->sink, sink->handlers, sink->closure);
+  d->top->sink = sink;
 
   /* If this fails, increase the value in decoder.h. */
   UPB_ASSERT_DEBUGVAR(upb_env_bytesallocated(e) - size_before <=
@@ -1038,8 +1037,8 @@ const upb_pbdecodermethod *upb_pbdecoder_method(const upb_pbdecoder *d) {
   return d->method_;
 }
 
-upb_bytessink *upb_pbdecoder_input(upb_pbdecoder *d) {
-  return &d->input_;
+upb_bytessink upb_pbdecoder_input(upb_pbdecoder *d) {
+  return d->input_;
 }
 
 size_t upb_pbdecoder_maxnesting(const upb_pbdecoder *d) {
diff --git a/upb/pb/decoder.h b/upb/pb/decoder.h
index 1ffcb7d..ba381f3 100644
--- a/upb/pb/decoder.h
+++ b/upb/pb/decoder.h
@@ -56,6 +56,7 @@ UPB_END_EXTERN_C
  * Handlers. */
 class upb::pb::DecoderMethodPtr {
  public:
+  DecoderMethodPtr() : ptr_(nullptr) {}
   DecoderMethodPtr(const upb_pbdecodermethod* ptr) : ptr_(ptr) {}
 
   const upb_pbdecodermethod* ptr() { return ptr_; }
@@ -98,9 +99,9 @@ UPB_BEGIN_EXTERN_C
 
 upb_pbdecoder *upb_pbdecoder_create(upb_env *e,
                                     const upb_pbdecodermethod *method,
-                                    upb_sink *output);
+                                    upb_sink output);
 const upb_pbdecodermethod *upb_pbdecoder_method(const upb_pbdecoder *d);
-upb_bytessink *upb_pbdecoder_input(upb_pbdecoder *d);
+upb_bytessink upb_pbdecoder_input(upb_pbdecoder *d);
 uint64_t upb_pbdecoder_bytesparsed(const upb_pbdecoder *d);
 size_t upb_pbdecoder_maxnesting(const upb_pbdecoder *d);
 bool upb_pbdecoder_setmaxnesting(upb_pbdecoder *d, size_t max);
@@ -124,8 +125,8 @@ class upb::pb::DecoderPtr {
    *
    * The sink must match the given method. */
   static DecoderPtr Create(Environment *env, DecoderMethodPtr method,
-                           upb_sink *output) {
-    return DecoderPtr(upb_pbdecoder_create(env, method.ptr(), output));
+                           upb::Sink output) {
+    return DecoderPtr(upb_pbdecoder_create(env, method.ptr(), output.sink()));
   }
 
   /* Returns the DecoderMethod this decoder is parsing from. */
@@ -134,7 +135,7 @@ class upb::pb::DecoderPtr {
   }
 
   /* The sink on which this decoder receives input. */
-  upb_bytessink* input() { return upb_pbdecoder_input(ptr()); }
+  BytesSink input() { return BytesSink(upb_pbdecoder_input(ptr())); }
 
   /* Returns number of bytes successfully parsed.
    *
diff --git a/upb/pb/encoder.c b/upb/pb/encoder.c
index 3497007..1496eba 100644
--- a/upb/pb/encoder.c
+++ b/upb/pb/encoder.c
@@ -95,7 +95,7 @@ struct upb_pb_encoder {
 
   /* Our input and output. */
   upb_sink input_;
-  upb_bytessink *output_;
+  upb_bytessink output_;
 
   /* The "subclosure" -- used as the inner closure as part of the bytessink
    * protocol. */
@@ -127,7 +127,7 @@ struct upb_pb_encoder {
 
 /* TODO(haberman): handle pushback */
 static void putbuf(upb_pb_encoder *e, const char *buf, size_t len) {
-  size_t n = upb_bytessink_putbuf(e->output_, e->subc, buf, len, NULL);
+  size_t n = upb_bytessink_putbuf(&e->output_, e->subc, buf, len, NULL);
   UPB_ASSERT(n == len);
 }
 
@@ -353,7 +353,7 @@ static bool startmsg(void *c, const void *hd) {
   upb_pb_encoder *e = c;
   UPB_UNUSED(hd);
   if (e->depth++ == 0) {
-    upb_bytessink_start(e->output_, 0, &e->subc);
+    upb_bytessink_start(&e->output_, 0, &e->subc);
   }
   return true;
 }
@@ -363,7 +363,7 @@ static bool endmsg(void *c, const void *hd, upb_status *status) {
   UPB_UNUSED(hd);
   UPB_UNUSED(status);
   if (--e->depth == 0) {
-    upb_bytessink_end(e->output_);
+    upb_bytessink_end(&e->output_);
   }
   return true;
 }
@@ -527,7 +527,7 @@ upb_handlercache *upb_pb_encoder_newcache() {
 }
 
 upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h,
-                                      upb_bytessink *output) {
+                                      upb_bytessink output) {
   const size_t initial_bufsize = 256;
   const size_t initial_segbufsize = 16;
   /* TODO(haberman): make this configurable. */
@@ -556,7 +556,7 @@ upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h,
 
   e->env = env;
   e->output_ = output;
-  e->subc = output->closure;
+  e->subc = output.closure;
   e->ptr = e->buf;
 
   /* If this fails, increase the value in encoder.h. */
@@ -565,4 +565,4 @@ upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h,
   return e;
 }
 
-upb_sink *upb_pb_encoder_input(upb_pb_encoder *e) { return &e->input_; }
+upb_sink upb_pb_encoder_input(upb_pb_encoder *e) { return e->input_; }
diff --git a/upb/pb/encoder.h b/upb/pb/encoder.h
index 20ce606..7aa2870 100644
--- a/upb/pb/encoder.h
+++ b/upb/pb/encoder.h
@@ -30,16 +30,16 @@ class EncoderPtr;
  * constructed.  This hint may be an overestimate for some build configurations.
  * But if the decoder library is upgraded without recompiling the application,
  * it may be an underestimate. */
-#define UPB_PB_ENCODER_SIZE 768
+#define UPB_PB_ENCODER_SIZE 784
 
 struct upb_pb_encoder;
 typedef struct upb_pb_encoder upb_pb_encoder;
 
 UPB_BEGIN_EXTERN_C
 
-upb_sink *upb_pb_encoder_input(upb_pb_encoder *p);
+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_bytessink* output);
+                                      upb_bytessink output);
 
 upb_handlercache *upb_pb_encoder_newcache();
 
@@ -56,12 +56,12 @@ 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,
-                         BytesSink* output) {
-    return EncoderPtr(upb_pb_encoder_create(env, handlers, output->ptr()));
+                           BytesSink output) {
+    return EncoderPtr(upb_pb_encoder_create(env, handlers, output.sink()));
   }
 
   /* The input to the encoder. */
-  upb_sink* input() { return upb_pb_encoder_input(ptr()); }
+  upb::Sink input() { return upb_pb_encoder_input(ptr()); }
 
   /* Creates a new set of handlers for this MessageDef. */
   static HandlerCache NewCache() {
diff --git a/upb/sink.c b/upb/sink.c
index d0197a6..6ef5718 100644
--- a/upb/sink.c
+++ b/upb/sink.c
@@ -1,17 +1,17 @@
 
 #include "upb/sink.h"
 
-bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink) {
+bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink sink) {
   void *subc;
   bool ret;
   upb_bufhandle handle = UPB_BUFHANDLE_INIT;
   handle.buf = buf;
-  ret = upb_bytessink_start(sink, len, &subc);
+  ret = upb_bytessink_start(&sink, len, &subc);
   if (ret && len != 0) {
-    ret = (upb_bytessink_putbuf(sink, subc, buf, len, &handle) >= len);
+    ret = (upb_bytessink_putbuf(&sink, subc, buf, len, &handle) >= len);
   }
   if (ret) {
-    ret = upb_bytessink_end(sink);
+    ret = upb_bytessink_end(&sink);
   }
   return ret;
 }
diff --git a/upb/sink.h b/upb/sink.h
index 8cab45d..1359c5e 100644
--- a/upb/sink.h
+++ b/upb/sink.h
@@ -237,6 +237,17 @@ class upb::Sink {
   /* Constructor with no initialization; must be Reset() before use. */
   Sink() {}
 
+  Sink(const Sink&) = default;
+  Sink& operator=(const Sink&) = default;
+
+  Sink(const upb_sink& sink) : sink_(sink) {}
+  Sink &operator=(const upb_sink &sink) {
+    sink_ = sink;
+    return *this;
+  }
+
+  upb_sink sink() { return sink_; }
+
   /* Constructs a new sink for the given frozen handlers and closure.
    *
    * TODO: once the Handlers know the expected closure type, verify that T
@@ -406,7 +417,16 @@ class upb::BytesSink {
  public:
   BytesSink() {}
 
-  upb_bytessink* ptr() { return &sink_; }
+  BytesSink(const BytesSink&) = default;
+  BytesSink& operator=(const BytesSink&) = default;
+
+  BytesSink(const upb_bytessink& sink) : sink_(sink) {}
+  BytesSink &operator=(const upb_bytessink &sink) {
+    sink_ = sink;
+    return *this;
+  }
+
+  upb_bytessink sink() { return sink_; }
 
   /* Constructs a new sink for the given frozen handlers and closure.
    *
@@ -444,15 +464,15 @@ class upb::BytesSink {
 
 UPB_BEGIN_EXTERN_C
 
-bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink);
+bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink sink);
 
 UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
 namespace upb {
-template <class T> bool PutBuffer(const T& str, upb_bytessink* sink) {
-  return upb_bufsrc_putbuf(str.c_str(), str.size(), sink);
+template <class T> bool PutBuffer(const T& str, BytesSink sink) {
+  return upb_bufsrc_putbuf(str.c_str(), str.size(), sink.sink());
 }
 }
 
-- 
cgit v1.2.3


From cb26d883d1290ed258e5594454c2ffe0526b13f9 Mon Sep 17 00:00:00 2001
From: Joshua Haberman <jhaberman@gmail.com>
Date: Mon, 14 Jan 2019 10:56:58 -0800
Subject: WIP.

---
 google/protobuf/descriptor.upb.h |   8 +-
 tests/conformance_upb.c          |  16 +--
 tests/json/test_json.cc          |   4 +-
 tests/pb/test_decoder.cc         |  14 +--
 tests/pb/test_encoder.cc         |   9 +-
 tests/test_cpp.cc                |   2 +-
 tests/test_util.h                |  21 ++--
 upb/bindings/lua/def.c           |   9 +-
 upb/bindings/lua/msg.c           |  13 +-
 upb/bindings/lua/upb/pb.c        |   8 +-
 upb/decode.h                     |   8 +-
 upb/def.c                        |  41 ++++---
 upb/def.h                        |  37 +++---
 upb/encode.h                     |   8 +-
 upb/generated_util.h             |   3 +-
 upb/handlers.c                   |   8 +-
 upb/handlers.h                   |  39 +++---
 upb/json/parser.c                | 259 ++++++++++++++++-----------------------
 upb/json/parser.h                |  37 +++---
 upb/json/parser.rl               | 153 +++++++++--------------
 upb/json/printer.c               |   8 +-
 upb/json/printer.h               |  14 ++-
 upb/msg.h                        |  28 ++---
 upb/msgfactory.h                 |  12 +-
 upb/pb/compile_decoder.c         |   2 +-
 upb/pb/decoder.c                 |  22 ++--
 upb/pb/decoder.h                 |  28 +++--
 upb/pb/decoder.int.h             |   4 +-
 upb/pb/encoder.c                 |  22 ++--
 upb/pb/encoder.h                 |  14 ++-
 upb/pb/textprinter.c             |  26 ++--
 upb/pb/textprinter.h             |  75 +++++-------
 upb/sink.c                       |  70 -----------
 upb/sink.h                       |  33 ++---
 upb/table.int.h                  |  15 ---
 upb/upb.c                        |  75 +++++-------
 upb/upb.h                        | 161 +++++++++---------------
 upbc/generator.cc                |   8 +-
 38 files changed, 555 insertions(+), 759 deletions(-)

(limited to 'upb/sink.c')

diff --git a/google/protobuf/descriptor.upb.h b/google/protobuf/descriptor.upb.h
index 32bccc7..7e62be5 100644
--- a/google/protobuf/descriptor.upb.h
+++ b/google/protobuf/descriptor.upb.h
@@ -16,7 +16,9 @@
 #include "upb/decode.h"
 #include "upb/encode.h"
 #include "upb/port_def.inc"
-UPB_BEGIN_EXTERN_C
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 struct google_protobuf_FileDescriptorSet;
 struct google_protobuf_FileDescriptorProto;
@@ -1668,7 +1670,9 @@ UPB_INLINE void google_protobuf_GeneratedCodeInfo_Annotation_set_end(google_prot
 }
 
 
-UPB_END_EXTERN_C
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
 
 #include "upb/port_undef.inc"
 
diff --git a/tests/conformance_upb.c b/tests/conformance_upb.c
index e0a7d8c..cefac4c 100644
--- a/tests/conformance_upb.c
+++ b/tests/conformance_upb.c
@@ -130,7 +130,7 @@ void DoTest(
 }
 
 bool DoTestIo() {
-  upb_arena arena;
+  upb_arena *arena;
   upb_alloc *alloc;
   upb_status status;
   char *serialized_input;
@@ -145,8 +145,8 @@ bool DoTestIo() {
     return false;
   }
 
-  upb_arena_init(&arena);
-  alloc = upb_arena_alloc(&arena);
+  arena = upb_arena_new();
+  alloc = upb_arena_alloc(arena);
   serialized_input = upb_malloc(alloc, input_size);
 
   if (!CheckedRead(STDIN_FILENO, serialized_input, input_size)) {
@@ -155,24 +155,26 @@ bool DoTestIo() {
   }
 
   request = conformance_ConformanceRequest_parsenew(
-      upb_stringview_make(serialized_input, input_size), &arena);
-  response = conformance_ConformanceResponse_new(&arena);
+      upb_stringview_make(serialized_input, input_size), arena);
+  response = conformance_ConformanceResponse_new(arena);
 
   if (request) {
-    DoTest(request, response, &arena);
+    DoTest(request, response, arena);
   } else {
     fprintf(stderr, "conformance_upb: parse of ConformanceRequest failed: %s\n",
             upb_status_errmsg(&status));
   }
 
   serialized_output = conformance_ConformanceResponse_serialize(
-      response, &arena, &output_size);
+      response, arena, &output_size);
 
   CheckedWrite(STDOUT_FILENO, &output_size, sizeof(uint32_t));
   CheckedWrite(STDOUT_FILENO, serialized_output, output_size);
 
   test_count++;
 
+  upb_arena_free(arena);
+
   return true;
 }
 
diff --git a/tests/json/test_json.cc b/tests/json/test_json.cc
index b0fd3e3..1f7d364 100644
--- a/tests/json/test_json.cc
+++ b/tests/json/test_json.cc
@@ -174,9 +174,9 @@ void test_json_roundtrip_message(const char* json_src,
   VerboseParserEnvironment env(verbose);
   StringSink data_sink;
   upb::json::PrinterPtr printer = upb::json::PrinterPtr::Create(
-      env.env(), serialize_handlers, data_sink.Sink());
+      env.arena(), serialize_handlers, data_sink.Sink());
   upb::json::ParserPtr parser = upb::json::ParserPtr::Create(
-      env.env(), parser_method, NULL, printer.input(), false);
+      env.arena(), parser_method, NULL, printer.input(), false);
   env.ResetBytesSink(parser.input());
   env.Reset(json_src, strlen(json_src), false, false);
 
diff --git a/tests/pb/test_decoder.cc b/tests/pb/test_decoder.cc
index ec7a788..b2dd812 100644
--- a/tests/pb/test_decoder.cc
+++ b/tests/pb/test_decoder.cc
@@ -452,10 +452,10 @@ void callback(const void *closure, upb::Handlers* h_ptr) {
 const upb::Handlers *global_handlers;
 upb::pb::DecoderMethodPtr global_method;
 
-upb::pb::DecoderPtr CreateDecoder(upb::Environment* env,
+upb::pb::DecoderPtr CreateDecoder(upb::Arena* arena,
                                   upb::pb::DecoderMethodPtr method,
                                   upb::Sink sink) {
-  upb::pb::DecoderPtr ret = upb::pb::DecoderPtr::Create(env, method, sink);
+  upb::pb::DecoderPtr ret = upb::pb::DecoderPtr::Create(arena, method, sink);
   ret.set_max_nesting(MAX_NESTING);
   return ret;
 }
@@ -556,7 +556,7 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::DecoderPtr decoder,
 void run_decoder(const string& proto, const string* expected_output) {
   VerboseParserEnvironment env(filter_hash != 0);
   upb::Sink sink(global_handlers, &closures[0]);
-  upb::pb::DecoderPtr decoder = CreateDecoder(env.env(), global_method, sink);
+  upb::pb::DecoderPtr decoder = CreateDecoder(env.arena(), global_method, sink);
   env.ResetBytesSink(decoder.input());
   for (size_t i = 0; i < proto.size(); i++) {
     for (size_t j = i; j < UPB_MIN(proto.size(), i + 5); j++) {
@@ -872,10 +872,9 @@ void test_valid() {
   if (!filter_hash || filter_hash == testhash) {
     testhash = emptyhash;
     upb::Status status;
-    upb::Environment env;
-    env.ReportErrorsTo(&status);
+    upb::Arena arena;
     upb::Sink sink(global_handlers, &closures[0]);
-    upb::pb::DecoderPtr decoder = CreateDecoder(&env, global_method, sink);
+    upb::pb::DecoderPtr decoder = CreateDecoder(&arena, global_method, sink);
     output.clear();
     bool ok = upb::PutBuffer(std::string(), decoder.input());
     ASSERT(ok);
@@ -1161,7 +1160,8 @@ void test_emptyhandlers(upb::SymbolTable* symtab, bool allowjit) {
   for (int i = 0; testdata[i].data; i++) {
     VerboseParserEnvironment env(filter_hash != 0);
     upb::Sink sink(global_method.dest_handlers(), &closures[0]);
-    upb::pb::DecoderPtr decoder = CreateDecoder(env.env(), global_method, sink);
+    upb::pb::DecoderPtr decoder =
+        CreateDecoder(env.arena(), global_method, sink);
     env.ResetBytesSink(decoder.input());
     env.Reset(testdata[i].data, testdata[i].length, true, false);
     ASSERT(env.Start());
diff --git a/tests/pb/test_encoder.cc b/tests/pb/test_encoder.cc
index 35c0e1e..7145097 100644
--- a/tests/pb/test_encoder.cc
+++ b/tests/pb/test_encoder.cc
@@ -24,7 +24,7 @@ void test_pb_roundtrip() {
   upb::Arena arena;
   google_protobuf_FileDescriptorSet *set =
       google_protobuf_FileDescriptorSet_parsenew(
-          upb_stringview_make(input.c_str(), input.size()), &arena);
+          upb_stringview_make(input.c_str(), input.size()), arena.ptr());
   ASSERT(set);
   size_t n;
   const google_protobuf_FileDescriptorProto *const *files =
@@ -33,7 +33,7 @@ void test_pb_roundtrip() {
   upb::Status status;
   bool ok = symtab.AddFile(files[0], &status);
   if (!ok) {
-    fprintf(stderr, "Error building def: %s\n", upb_status_errmsg(&status));
+    fprintf(stderr, "Error building def: %s\n", status.error_message());
     ASSERT(false);
   }
   upb::MessageDefPtr md =
@@ -43,13 +43,12 @@ void test_pb_roundtrip() {
   ASSERT(encoder_handlers);
   const upb::pb::DecoderMethodPtr method = decoder_cache.Get(md);
 
-  upb::InlinedEnvironment<512> env;
   std::string output;
   upb::StringSink string_sink(&output);
   upb::pb::EncoderPtr encoder =
-      upb::pb::EncoderPtr::Create(&env, encoder_handlers, string_sink.input());
+      upb::pb::EncoderPtr::Create(&arena, encoder_handlers, string_sink.input());
   upb::pb::DecoderPtr decoder =
-      upb::pb::DecoderPtr::Create(&env, method, encoder.input());
+      upb::pb::DecoderPtr::Create(&arena, method, encoder.input());
   ok = upb::PutBuffer(input, decoder.input());
   ASSERT(ok);
   ASSERT(input == output);
diff --git a/tests/test_cpp.cc b/tests/test_cpp.cc
index a5bfbc7..5e9a8dd 100644
--- a/tests/test_cpp.cc
+++ b/tests/test_cpp.cc
@@ -672,7 +672,7 @@ void DoNothingStringBufHandler(C* closure, const char *buf, size_t len) {
 }
 
 template <class C>
-void DoNothingEndMessageHandler(C* closure, upb::Status *status) {
+void DoNothingEndMessageHandler(C* closure, upb_status *status) {
   UPB_UNUSED(closure);
   UPB_UNUSED(status);
 }
diff --git a/tests/test_util.h b/tests/test_util.h
index 0b5ddd4..04ca3fb 100644
--- a/tests/test_util.h
+++ b/tests/test_util.h
@@ -30,15 +30,11 @@ upb_bufhandle global_handle;
 class VerboseParserEnvironment {
  public:
   /* Pass verbose=true to print detailed diagnostics to stderr. */
-  VerboseParserEnvironment(bool verbose) : verbose_(verbose) {
-    env_.SetErrorFunction(&VerboseParserEnvironment::OnError, this);
-  }
+  VerboseParserEnvironment(bool verbose) : verbose_(verbose) {}
 
   static bool OnError(void *ud, const upb::Status* status) {
     VerboseParserEnvironment* env = static_cast<VerboseParserEnvironment*>(ud);
 
-    env->saw_error_ = true;
-
     if (env->expect_error_ && env->verbose_) {
       fprintf(stderr, "Encountered error, as expected: ");
     } else if (!env->expect_error_) {
@@ -56,7 +52,6 @@ class VerboseParserEnvironment {
     len_ = len;
     ofs_ = 0;
     expect_error_ = expect_error;
-    saw_error_ = false;
     end_ok_set_ = false;
     skip_until_ = may_skip ? 0 : -1;
     skipped_with_null_ = false;
@@ -94,12 +89,12 @@ class VerboseParserEnvironment {
   bool CheckConsistency() {
     /* If we called end (which we should only do when previous bytes are fully
      * accepted), then end() should return true iff there were no errors. */
-    if (end_ok_set_ && end_ok_ != !saw_error_) {
+    if (end_ok_set_ && end_ok_ != status_.ok()) {
       fprintf(stderr, "End() status and saw_error didn't match.\n");
       return false;
     }
 
-    if (expect_error_ && !saw_error_) {
+    if (expect_error_ && status_.ok()) {
       fprintf(stderr, "Expected error but saw none.\n");
       return false;
     }
@@ -158,8 +153,9 @@ class VerboseParserEnvironment {
       }
     }
 
-    if (saw_error_)
+    if (!status_.ok()) {
       return false;
+    }
 
     if (parsed > bytes && skip_until_ >= 0) {
       skip_until_ = ofs_ + parsed;
@@ -175,12 +171,14 @@ class VerboseParserEnvironment {
   }
 
   size_t ofs() { return ofs_; }
-  upb::Environment* env() { return &env_; }
 
   bool SkippedWithNull() { return skipped_with_null_; }
 
+  upb::Arena* arena() { return &arena_; }
+
  private:
-  upb::Environment env_;
+  upb::Arena arena_;
+  upb::Status status_;
   upb::BytesSink sink_;
   const char* buf_;
   size_t len_;
@@ -188,7 +186,6 @@ class VerboseParserEnvironment {
   size_t ofs_;
   void *subc_;
   bool expect_error_;
-  bool saw_error_;
   bool end_ok_;
   bool end_ok_set_;
 
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 */
diff --git a/upbc/generator.cc b/upbc/generator.cc
index ddfaa7b..de40eee 100644
--- a/upbc/generator.cc
+++ b/upbc/generator.cc
@@ -502,7 +502,9 @@ void WriteHeader(const protobuf::FileDescriptor* file, Output& output) {
       "#include \"upb/decode.h\"\n"
       "#include \"upb/encode.h\"\n"
       "#include \"upb/port_def.inc\"\n"
-      "UPB_BEGIN_EXTERN_C\n\n",
+      "#ifdef __cplusplus\n"
+      "extern \"C\" {\n"
+      "#endif\n\n",
       ToPreproc(file->name()));
 
   // Forward-declare types defined in this file.
@@ -548,7 +550,9 @@ void WriteHeader(const protobuf::FileDescriptor* file, Output& output) {
   }
 
   output(
-      "UPB_END_EXTERN_C\n"
+      "#ifdef __cplusplus\n"
+      "}  /* extern \"C\" */\n"
+      "#endif\n"
       "\n"
       "#include \"upb/port_undef.inc\"\n"
       "\n"
-- 
cgit v1.2.3


From f30c7f4acbe0457aa41597f034765d94eb39e739 Mon Sep 17 00:00:00 2001
From: Joshua Haberman <jhaberman@gmail.com>
Date: Tue, 15 Jan 2019 07:14:48 -0800
Subject: Take sinks by value.

---
 upb/json/parser.c    |  80 +++++++++++-----------
 upb/json/parser.rl   |  80 +++++++++++-----------
 upb/json/printer.c   |  18 ++---
 upb/pb/decoder.c     |  22 +++---
 upb/pb/encoder.c     |   6 +-
 upb/pb/textprinter.c |  16 ++---
 upb/sink.c           |   6 +-
 upb/sink.h           | 186 +++++++++++++++++++++++++--------------------------
 8 files changed, 207 insertions(+), 207 deletions(-)

(limited to 'upb/sink.c')

diff --git a/upb/json/parser.c b/upb/json/parser.c
index 5fe20ef..70ebfcf 100644
--- a/upb/json/parser.c
+++ b/upb/json/parser.c
@@ -487,7 +487,7 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
     output[0] = val >> 16;
     output[1] = (val >> 8) & 0xff;
     output[2] = val & 0xff;
-    upb_sink_putstring(&p->top->sink, sel, output, 3, NULL);
+    upb_sink_putstring(p->top->sink, sel, output, 3, NULL);
   }
   return true;
 
@@ -512,7 +512,7 @@ otherchar:
 
     UPB_ASSERT(!(val & 0x80000000));
     output = val >> 16;
-    upb_sink_putstring(&p->top->sink, sel, &output, 1, NULL);
+    upb_sink_putstring(p->top->sink, sel, &output, 1, NULL);
     return true;
   } else {
     uint32_t val;
@@ -529,7 +529,7 @@ otherchar:
 
     output[0] = val >> 16;
     output[1] = (val >> 8) & 0xff;
-    upb_sink_putstring(&p->top->sink, sel, output, 2, NULL);
+    upb_sink_putstring(p->top->sink, sel, output, 2, NULL);
     return true;
   }
 
@@ -695,7 +695,7 @@ static bool multipart_text(upb_json_parser *p, const char *buf, size_t len,
 
     case MULTIPART_PUSHEAGERLY: {
       const upb_bufhandle *handle = can_alias ? p->handle : NULL;
-      upb_sink_putstring(&p->top->sink, p->string_selector, buf, len, handle);
+      upb_sink_putstring(p->top->sink, p->string_selector, buf, len, handle);
       break;
     }
   }
@@ -941,7 +941,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (val > INT32_MAX || val < INT32_MIN) {
         return false;
       } else {
-        upb_sink_putint32(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putint32(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -952,7 +952,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (val > UINT32_MAX || errno == ERANGE) {
         return false;
       } else {
-        upb_sink_putuint32(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putuint32(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -963,7 +963,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       if (errno == ERANGE || end != bufend) {
         break;
       } else {
-        upb_sink_putint64(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putint64(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -974,7 +974,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (errno == ERANGE) {
         return false;
       } else {
-        upb_sink_putuint64(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putuint64(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -1005,7 +1005,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       if (modf(val, &dummy) != 0 || val > max || val < min) {             \
         return false;                                                     \
       } else {                                                            \
-        upb_sink_put ## smalltype(&p->top->sink, parser_getsel(p),        \
+        upb_sink_put ## smalltype(p->top->sink, parser_getsel(p),        \
                                   (ctype)val);                            \
         return true;                                                      \
       }                                                                   \
@@ -1019,13 +1019,13 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
 #undef CASE
 
     case UPB_TYPE_DOUBLE:
-      upb_sink_putdouble(&p->top->sink, parser_getsel(p), val);
+      upb_sink_putdouble(p->top->sink, parser_getsel(p), val);
       return true;
     case UPB_TYPE_FLOAT:
       if ((val > FLT_MAX || val < -FLT_MAX) && val != inf && val != -inf) {
         return false;
       } else {
-        upb_sink_putfloat(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putfloat(p->top->sink, parser_getsel(p), val);
         return true;
       }
     default:
@@ -1069,7 +1069,7 @@ static bool parser_putbool(upb_json_parser *p, bool val) {
     return false;
   }
 
-  ok = upb_sink_putbool(&p->top->sink, parser_getsel(p), val);
+  ok = upb_sink_putbool(p->top->sink, parser_getsel(p), val);
   UPB_ASSERT(ok);
 
   return true;
@@ -1209,7 +1209,7 @@ static bool start_stringval(upb_json_parser *p) {
      * handler frames, and string events occur in a sub-frame. */
     inner = p->top + 1;
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-    upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+    upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
     inner->m = p->top->m;
     inner->f = p->top->f;
     inner->name_table = NULL;
@@ -1258,11 +1258,11 @@ static bool end_any_stringval(upb_json_parser *p) {
   inner = p->top + 1;
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-  upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+  upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-  upb_sink_putstring(&inner->sink, sel, buf, len, NULL);
+  upb_sink_putstring(inner->sink, sel, buf, len, NULL);
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-  upb_sink_endstr(&inner->sink, sel);
+  upb_sink_endstr(inner->sink, sel);
 
   multipart_end(p);
 
@@ -1318,7 +1318,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
     case UPB_TYPE_STRING: {
       upb_selector_t sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
       p->top--;
-      upb_sink_endstr(&p->top->sink, sel);
+      upb_sink_endstr(p->top->sink, sel);
       break;
     }
 
@@ -1334,7 +1334,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
 
       if (ok) {
         upb_selector_t sel = parser_getsel(p);
-        upb_sink_putint32(&p->top->sink, sel, int_val);
+        upb_sink_putint32(p->top->sink, sel, int_val);
       } else {
         upb_status_seterrf(p->status, "Enum value unknown: '%.*s'", len, buf);
       }
@@ -1472,7 +1472,7 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   capture_begin(p, seconds_membername);
   capture_end(p, seconds_membername + 7);
   end_membername(p);
-  upb_sink_putint64(&p->top->sink, parser_getsel(p), seconds);
+  upb_sink_putint64(p->top->sink, parser_getsel(p), seconds);
   end_member(p);
 
   /* Set nanos */
@@ -1480,7 +1480,7 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   capture_begin(p, nanos_membername);
   capture_end(p, nanos_membername + 5);
   end_membername(p);
-  upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
+  upb_sink_putint32(p->top->sink, parser_getsel(p), nanos);
   end_member(p);
 
   /* Continue previous arena */
@@ -1572,7 +1572,7 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   capture_begin(p, nanos_membername);
   capture_end(p, nanos_membername + 5);
   end_membername(p);
-  upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
+  upb_sink_putint32(p->top->sink, parser_getsel(p), nanos);
   end_member(p);
 
   /* Continue previous environment */
@@ -1630,7 +1630,7 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
   capture_begin(p, seconds_membername);
   capture_end(p, seconds_membername + 7);
   end_membername(p);
-  upb_sink_putint64(&p->top->sink, parser_getsel(p), seconds);
+  upb_sink_putint64(p->top->sink, parser_getsel(p), seconds);
   end_member(p);
 
   /* Continue previous environment */
@@ -1692,11 +1692,11 @@ static bool parse_mapentry_key(upb_json_parser *p) {
     case UPB_TYPE_BYTES: {
       upb_sink subsink;
       upb_selector_t sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-      upb_sink_startstr(&p->top->sink, sel, len, &subsink);
+      upb_sink_startstr(p->top->sink, sel, len, &subsink);
       sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-      upb_sink_putstring(&subsink, sel, buf, len, NULL);
+      upb_sink_putstring(subsink, sel, buf, len, NULL);
       sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-      upb_sink_endstr(&p->top->sink, sel);
+      upb_sink_endstr(p->top->sink, sel);
       multipart_end(p);
       break;
     }
@@ -1734,7 +1734,7 @@ static bool handle_mapentry(upb_json_parser *p) {
   inner = p->top + 1;
   p->top->f = mapfield;
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSUBMSG);
-  upb_sink_startsubmsg(&p->top->sink, sel, &inner->sink);
+  upb_sink_startsubmsg(p->top->sink, sel, &inner->sink);
   inner->m = mapentrymsg;
   inner->name_table = NULL;
   inner->mapfield = mapfield;
@@ -1751,7 +1751,7 @@ static bool handle_mapentry(upb_json_parser *p) {
   p->top = inner;
 
   /* send STARTMSG in submsg frame. */
-  upb_sink_startmsg(&p->top->sink);
+  upb_sink_startmsg(p->top->sink);
 
   parse_mapentry_key(p);
 
@@ -1827,14 +1827,14 @@ static void end_member(upb_json_parser *p) {
 
     UPB_ASSERT(p->top > p->stack);
     /* send ENDMSG on submsg. */
-    upb_sink_endmsg(&p->top->sink, p->status);
+    upb_sink_endmsg(p->top->sink, p->status);
     mapfield = p->top->mapfield;
 
     /* send ENDSUBMSG in repeated-field-of-mapentries frame. */
     p->top--;
     ok = upb_handlers_getselector(mapfield, UPB_HANDLER_ENDSUBMSG, &sel);
     UPB_ASSERT(ok);
-    upb_sink_endsubmsg(&p->top->sink, sel);
+    upb_sink_endsubmsg(p->top->sink, sel);
   }
 
   p->top->f = NULL;
@@ -1878,7 +1878,7 @@ static bool start_subobject(upb_json_parser *p) {
 
     inner = p->top + 1;
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSEQ);
-    upb_sink_startseq(&p->top->sink, sel, &inner->sink);
+    upb_sink_startseq(p->top->sink, sel, &inner->sink);
     inner->m = upb_fielddef_msgsubdef(p->top->f);
     inner->name_table = NULL;
     inner->mapfield = p->top->f;
@@ -1902,7 +1902,7 @@ static bool start_subobject(upb_json_parser *p) {
     inner = p->top + 1;
 
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSUBMSG);
-    upb_sink_startsubmsg(&p->top->sink, sel, &inner->sink);
+    upb_sink_startsubmsg(p->top->sink, sel, &inner->sink);
     inner->m = upb_fielddef_msgsubdef(p->top->f);
     set_name_table(p, inner);
     inner->f = NULL;
@@ -1961,14 +1961,14 @@ static void end_subobject(upb_json_parser *p) {
     upb_selector_t sel;
     p->top--;
     sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSEQ);
-    upb_sink_endseq(&p->top->sink, sel);
+    upb_sink_endseq(p->top->sink, sel);
   } else {
     upb_selector_t sel;
     bool is_unknown = p->top->m == NULL;
     p->top--;
     if (!is_unknown) {
       sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSUBMSG);
-      upb_sink_endsubmsg(&p->top->sink, sel);
+      upb_sink_endsubmsg(p->top->sink, sel);
     }
   }
 }
@@ -2041,7 +2041,7 @@ static bool start_array(upb_json_parser *p) {
 
   inner = p->top + 1;
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSEQ);
-  upb_sink_startseq(&p->top->sink, sel, &inner->sink);
+  upb_sink_startseq(p->top->sink, sel, &inner->sink);
   inner->m = p->top->m;
   inner->name_table = NULL;
   inner->f = p->top->f;
@@ -2067,7 +2067,7 @@ static void end_array(upb_json_parser *p) {
   }
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSEQ);
-  upb_sink_endseq(&p->top->sink, sel);
+  upb_sink_endseq(p->top->sink, sel);
 
   if (is_wellknown_msg(p, UPB_WELLKNOWN_LISTVALUE)) {
     end_listvalue_object(p);
@@ -2086,13 +2086,13 @@ static void end_array(upb_json_parser *p) {
 
 static void start_object(upb_json_parser *p) {
   if (!p->top->is_map && p->top->m != NULL) {
-    upb_sink_startmsg(&p->top->sink);
+    upb_sink_startmsg(p->top->sink);
   }
 }
 
 static void end_object(upb_json_parser *p) {
   if (!p->top->is_map && p->top->m != NULL) {
-    upb_sink_endmsg(&p->top->sink, p->status);
+    upb_sink_endmsg(p->top->sink, p->status);
   }
 }
 
@@ -2198,12 +2198,12 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
   inner = p->top + 1;
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-  upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+  upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-  upb_sink_putstring(&inner->sink, sel, p->top->any_frame->stringsink.ptr,
+  upb_sink_putstring(inner->sink, sel, p->top->any_frame->stringsink.ptr,
                      p->top->any_frame->stringsink.len, NULL);
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-  upb_sink_endstr(&inner->sink, sel);
+  upb_sink_endstr(inner->sink, sel);
 
   end_member(p);
 
diff --git a/upb/json/parser.rl b/upb/json/parser.rl
index 6f27630..11a6955 100644
--- a/upb/json/parser.rl
+++ b/upb/json/parser.rl
@@ -485,7 +485,7 @@ static bool base64_push(upb_json_parser *p, upb_selector_t sel, const char *ptr,
     output[0] = val >> 16;
     output[1] = (val >> 8) & 0xff;
     output[2] = val & 0xff;
-    upb_sink_putstring(&p->top->sink, sel, output, 3, NULL);
+    upb_sink_putstring(p->top->sink, sel, output, 3, NULL);
   }
   return true;
 
@@ -510,7 +510,7 @@ otherchar:
 
     UPB_ASSERT(!(val & 0x80000000));
     output = val >> 16;
-    upb_sink_putstring(&p->top->sink, sel, &output, 1, NULL);
+    upb_sink_putstring(p->top->sink, sel, &output, 1, NULL);
     return true;
   } else {
     uint32_t val;
@@ -527,7 +527,7 @@ otherchar:
 
     output[0] = val >> 16;
     output[1] = (val >> 8) & 0xff;
-    upb_sink_putstring(&p->top->sink, sel, output, 2, NULL);
+    upb_sink_putstring(p->top->sink, sel, output, 2, NULL);
     return true;
   }
 
@@ -693,7 +693,7 @@ static bool multipart_text(upb_json_parser *p, const char *buf, size_t len,
 
     case MULTIPART_PUSHEAGERLY: {
       const upb_bufhandle *handle = can_alias ? p->handle : NULL;
-      upb_sink_putstring(&p->top->sink, p->string_selector, buf, len, handle);
+      upb_sink_putstring(p->top->sink, p->string_selector, buf, len, handle);
       break;
     }
   }
@@ -939,7 +939,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (val > INT32_MAX || val < INT32_MIN) {
         return false;
       } else {
-        upb_sink_putint32(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putint32(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -950,7 +950,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (val > UINT32_MAX || errno == ERANGE) {
         return false;
       } else {
-        upb_sink_putuint32(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putuint32(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -961,7 +961,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       if (errno == ERANGE || end != bufend) {
         break;
       } else {
-        upb_sink_putint64(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putint64(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -972,7 +972,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       } else if (errno == ERANGE) {
         return false;
       } else {
-        upb_sink_putuint64(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putuint64(p->top->sink, parser_getsel(p), val);
         return true;
       }
     }
@@ -1003,7 +1003,7 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
       if (modf(val, &dummy) != 0 || val > max || val < min) {             \
         return false;                                                     \
       } else {                                                            \
-        upb_sink_put ## smalltype(&p->top->sink, parser_getsel(p),        \
+        upb_sink_put ## smalltype(p->top->sink, parser_getsel(p),        \
                                   (ctype)val);                            \
         return true;                                                      \
       }                                                                   \
@@ -1017,13 +1017,13 @@ static bool parse_number_from_buffer(upb_json_parser *p, const char *buf,
 #undef CASE
 
     case UPB_TYPE_DOUBLE:
-      upb_sink_putdouble(&p->top->sink, parser_getsel(p), val);
+      upb_sink_putdouble(p->top->sink, parser_getsel(p), val);
       return true;
     case UPB_TYPE_FLOAT:
       if ((val > FLT_MAX || val < -FLT_MAX) && val != inf && val != -inf) {
         return false;
       } else {
-        upb_sink_putfloat(&p->top->sink, parser_getsel(p), val);
+        upb_sink_putfloat(p->top->sink, parser_getsel(p), val);
         return true;
       }
     default:
@@ -1067,7 +1067,7 @@ static bool parser_putbool(upb_json_parser *p, bool val) {
     return false;
   }
 
-  ok = upb_sink_putbool(&p->top->sink, parser_getsel(p), val);
+  ok = upb_sink_putbool(p->top->sink, parser_getsel(p), val);
   UPB_ASSERT(ok);
 
   return true;
@@ -1207,7 +1207,7 @@ static bool start_stringval(upb_json_parser *p) {
      * handler frames, and string events occur in a sub-frame. */
     inner = p->top + 1;
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-    upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+    upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
     inner->m = p->top->m;
     inner->f = p->top->f;
     inner->name_table = NULL;
@@ -1256,11 +1256,11 @@ static bool end_any_stringval(upb_json_parser *p) {
   inner = p->top + 1;
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-  upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+  upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-  upb_sink_putstring(&inner->sink, sel, buf, len, NULL);
+  upb_sink_putstring(inner->sink, sel, buf, len, NULL);
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-  upb_sink_endstr(&inner->sink, sel);
+  upb_sink_endstr(inner->sink, sel);
 
   multipart_end(p);
 
@@ -1316,7 +1316,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
     case UPB_TYPE_STRING: {
       upb_selector_t sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
       p->top--;
-      upb_sink_endstr(&p->top->sink, sel);
+      upb_sink_endstr(p->top->sink, sel);
       break;
     }
 
@@ -1332,7 +1332,7 @@ static bool end_stringval_nontop(upb_json_parser *p) {
 
       if (ok) {
         upb_selector_t sel = parser_getsel(p);
-        upb_sink_putint32(&p->top->sink, sel, int_val);
+        upb_sink_putint32(p->top->sink, sel, int_val);
       } else {
         upb_status_seterrf(p->status, "Enum value unknown: '%.*s'", len, buf);
       }
@@ -1470,7 +1470,7 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   capture_begin(p, seconds_membername);
   capture_end(p, seconds_membername + 7);
   end_membername(p);
-  upb_sink_putint64(&p->top->sink, parser_getsel(p), seconds);
+  upb_sink_putint64(p->top->sink, parser_getsel(p), seconds);
   end_member(p);
 
   /* Set nanos */
@@ -1478,7 +1478,7 @@ static bool end_duration_base(upb_json_parser *p, const char *ptr) {
   capture_begin(p, nanos_membername);
   capture_end(p, nanos_membername + 5);
   end_membername(p);
-  upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
+  upb_sink_putint32(p->top->sink, parser_getsel(p), nanos);
   end_member(p);
 
   /* Continue previous arena */
@@ -1570,7 +1570,7 @@ static bool end_timestamp_fraction(upb_json_parser *p, const char *ptr) {
   capture_begin(p, nanos_membername);
   capture_end(p, nanos_membername + 5);
   end_membername(p);
-  upb_sink_putint32(&p->top->sink, parser_getsel(p), nanos);
+  upb_sink_putint32(p->top->sink, parser_getsel(p), nanos);
   end_member(p);
 
   /* Continue previous environment */
@@ -1628,7 +1628,7 @@ static bool end_timestamp_zone(upb_json_parser *p, const char *ptr) {
   capture_begin(p, seconds_membername);
   capture_end(p, seconds_membername + 7);
   end_membername(p);
-  upb_sink_putint64(&p->top->sink, parser_getsel(p), seconds);
+  upb_sink_putint64(p->top->sink, parser_getsel(p), seconds);
   end_member(p);
 
   /* Continue previous environment */
@@ -1690,11 +1690,11 @@ static bool parse_mapentry_key(upb_json_parser *p) {
     case UPB_TYPE_BYTES: {
       upb_sink subsink;
       upb_selector_t sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-      upb_sink_startstr(&p->top->sink, sel, len, &subsink);
+      upb_sink_startstr(p->top->sink, sel, len, &subsink);
       sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-      upb_sink_putstring(&subsink, sel, buf, len, NULL);
+      upb_sink_putstring(subsink, sel, buf, len, NULL);
       sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-      upb_sink_endstr(&p->top->sink, sel);
+      upb_sink_endstr(p->top->sink, sel);
       multipart_end(p);
       break;
     }
@@ -1732,7 +1732,7 @@ static bool handle_mapentry(upb_json_parser *p) {
   inner = p->top + 1;
   p->top->f = mapfield;
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSUBMSG);
-  upb_sink_startsubmsg(&p->top->sink, sel, &inner->sink);
+  upb_sink_startsubmsg(p->top->sink, sel, &inner->sink);
   inner->m = mapentrymsg;
   inner->name_table = NULL;
   inner->mapfield = mapfield;
@@ -1749,7 +1749,7 @@ static bool handle_mapentry(upb_json_parser *p) {
   p->top = inner;
 
   /* send STARTMSG in submsg frame. */
-  upb_sink_startmsg(&p->top->sink);
+  upb_sink_startmsg(p->top->sink);
 
   parse_mapentry_key(p);
 
@@ -1825,14 +1825,14 @@ static void end_member(upb_json_parser *p) {
 
     UPB_ASSERT(p->top > p->stack);
     /* send ENDMSG on submsg. */
-    upb_sink_endmsg(&p->top->sink, p->status);
+    upb_sink_endmsg(p->top->sink, p->status);
     mapfield = p->top->mapfield;
 
     /* send ENDSUBMSG in repeated-field-of-mapentries frame. */
     p->top--;
     ok = upb_handlers_getselector(mapfield, UPB_HANDLER_ENDSUBMSG, &sel);
     UPB_ASSERT(ok);
-    upb_sink_endsubmsg(&p->top->sink, sel);
+    upb_sink_endsubmsg(p->top->sink, sel);
   }
 
   p->top->f = NULL;
@@ -1876,7 +1876,7 @@ static bool start_subobject(upb_json_parser *p) {
 
     inner = p->top + 1;
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSEQ);
-    upb_sink_startseq(&p->top->sink, sel, &inner->sink);
+    upb_sink_startseq(p->top->sink, sel, &inner->sink);
     inner->m = upb_fielddef_msgsubdef(p->top->f);
     inner->name_table = NULL;
     inner->mapfield = p->top->f;
@@ -1900,7 +1900,7 @@ static bool start_subobject(upb_json_parser *p) {
     inner = p->top + 1;
 
     sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSUBMSG);
-    upb_sink_startsubmsg(&p->top->sink, sel, &inner->sink);
+    upb_sink_startsubmsg(p->top->sink, sel, &inner->sink);
     inner->m = upb_fielddef_msgsubdef(p->top->f);
     set_name_table(p, inner);
     inner->f = NULL;
@@ -1959,14 +1959,14 @@ static void end_subobject(upb_json_parser *p) {
     upb_selector_t sel;
     p->top--;
     sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSEQ);
-    upb_sink_endseq(&p->top->sink, sel);
+    upb_sink_endseq(p->top->sink, sel);
   } else {
     upb_selector_t sel;
     bool is_unknown = p->top->m == NULL;
     p->top--;
     if (!is_unknown) {
       sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSUBMSG);
-      upb_sink_endsubmsg(&p->top->sink, sel);
+      upb_sink_endsubmsg(p->top->sink, sel);
     }
   }
 }
@@ -2039,7 +2039,7 @@ static bool start_array(upb_json_parser *p) {
 
   inner = p->top + 1;
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSEQ);
-  upb_sink_startseq(&p->top->sink, sel, &inner->sink);
+  upb_sink_startseq(p->top->sink, sel, &inner->sink);
   inner->m = p->top->m;
   inner->name_table = NULL;
   inner->f = p->top->f;
@@ -2065,7 +2065,7 @@ static void end_array(upb_json_parser *p) {
   }
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSEQ);
-  upb_sink_endseq(&p->top->sink, sel);
+  upb_sink_endseq(p->top->sink, sel);
 
   if (is_wellknown_msg(p, UPB_WELLKNOWN_LISTVALUE)) {
     end_listvalue_object(p);
@@ -2084,13 +2084,13 @@ static void end_array(upb_json_parser *p) {
 
 static void start_object(upb_json_parser *p) {
   if (!p->top->is_map && p->top->m != NULL) {
-    upb_sink_startmsg(&p->top->sink);
+    upb_sink_startmsg(p->top->sink);
   }
 }
 
 static void end_object(upb_json_parser *p) {
   if (!p->top->is_map && p->top->m != NULL) {
-    upb_sink_endmsg(&p->top->sink, p->status);
+    upb_sink_endmsg(p->top->sink, p->status);
   }
 }
 
@@ -2196,12 +2196,12 @@ static bool end_any_object(upb_json_parser *p, const char *ptr) {
   inner = p->top + 1;
 
   sel = getsel_for_handlertype(p, UPB_HANDLER_STARTSTR);
-  upb_sink_startstr(&p->top->sink, sel, 0, &inner->sink);
+  upb_sink_startstr(p->top->sink, sel, 0, &inner->sink);
   sel = getsel_for_handlertype(p, UPB_HANDLER_STRING);
-  upb_sink_putstring(&inner->sink, sel, p->top->any_frame->stringsink.ptr,
+  upb_sink_putstring(inner->sink, sel, p->top->any_frame->stringsink.ptr,
                      p->top->any_frame->stringsink.len, NULL);
   sel = getsel_for_handlertype(p, UPB_HANDLER_ENDSTR);
-  upb_sink_endstr(&inner->sink, sel);
+  upb_sink_endstr(inner->sink, sel);
 
   end_member(p);
 
diff --git a/upb/json/printer.c b/upb/json/printer.c
index bc18055..2bc978a 100644
--- a/upb/json/printer.c
+++ b/upb/json/printer.c
@@ -87,7 +87,7 @@ strpc *newstrpc_str(upb_handlers *h, const char * str) {
 static void print_data(
     upb_json_printer *p, const char *buf, unsigned int len) {
   /* TODO: Will need to change if we support pushback from the sink. */
-  size_t n = upb_bytessink_putbuf(&p->output_, p->subc_, buf, len, NULL);
+  size_t n = upb_bytessink_putbuf(p->output_, p->subc_, buf, len, NULL);
   UPB_ASSERT(n == len);
 }
 
@@ -369,7 +369,7 @@ static bool printer_startmsg(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(&p->output_, 0, &p->subc_);
+    upb_bytessink_start(p->output_, 0, &p->subc_);
   }
   start_frame(p);
   return true;
@@ -381,7 +381,7 @@ static bool printer_endmsg(void *closure, const void *handler_data, upb_status *
   UPB_UNUSED(s);
   end_frame(p);
   if (p->depth_ == 0) {
-    upb_bytessink_end(&p->output_);
+    upb_bytessink_end(p->output_);
   }
   return true;
 }
@@ -770,7 +770,7 @@ static bool printer_startdurationmsg(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(&p->output_, 0, &p->subc_);
+    upb_bytessink_start(p->output_, 0, &p->subc_);
   }
   return true;
 }
@@ -828,7 +828,7 @@ static bool printer_enddurationmsg(void *closure, const void *handler_data,
   print_data(p, "\"", 1);
 
   if (p->depth_ == 0) {
-    upb_bytessink_end(&p->output_);
+    upb_bytessink_end(p->output_);
   }
 
   UPB_UNUSED(handler_data);
@@ -839,7 +839,7 @@ static bool printer_starttimestampmsg(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(&p->output_, 0, &p->subc_);
+    upb_bytessink_start(p->output_, 0, &p->subc_);
   }
   return true;
 }
@@ -902,7 +902,7 @@ static bool printer_endtimestampmsg(void *closure, const void *handler_data,
   print_data(p, "\"", 1);
 
   if (p->depth_ == 0) {
-    upb_bytessink_end(&p->output_);
+    upb_bytessink_end(p->output_);
   }
 
   UPB_UNUSED(handler_data);
@@ -914,7 +914,7 @@ static bool printer_startmsg_noframe(void *closure, const void *handler_data) {
   upb_json_printer *p = closure;
   UPB_UNUSED(handler_data);
   if (p->depth_ == 0) {
-    upb_bytessink_start(&p->output_, 0, &p->subc_);
+    upb_bytessink_start(p->output_, 0, &p->subc_);
   }
   return true;
 }
@@ -925,7 +925,7 @@ static bool printer_endmsg_noframe(
   UPB_UNUSED(handler_data);
   UPB_UNUSED(s);
   if (p->depth_ == 0) {
-    upb_bytessink_end(&p->output_);
+    upb_bytessink_end(p->output_);
   }
   return true;
 }
diff --git a/upb/pb/decoder.c b/upb/pb/decoder.c
index f1617db..2384312 100644
--- a/upb/pb/decoder.c
+++ b/upb/pb/decoder.c
@@ -594,7 +594,7 @@ have_tag:
 
     if (d->top->groupnum >= 0) {
       /* TODO: More code needed for handling unknown groups. */
-      upb_sink_putunknown(&d->top->sink, d->checkpoint, d->ptr - d->checkpoint);
+      upb_sink_putunknown(d->top->sink, d->checkpoint, d->ptr - d->checkpoint);
       return DECODE_OK;
     }
 
@@ -688,7 +688,7 @@ size_t run_decoder_vm(upb_pbdecoder *d, const mgroup *group,
   VMCASE(OP_PARSE_ ## type, { \
     ctype val; \
     CHECK_RETURN(decode_ ## wt(d, &val)); \
-    upb_sink_put ## name(&d->top->sink, arg, (convfunc)(val)); \
+    upb_sink_put ## name(d->top->sink, arg, (convfunc)(val)); \
   })
 
   while(1) {
@@ -740,36 +740,36 @@ size_t run_decoder_vm(upb_pbdecoder *d, const mgroup *group,
         d->pc += sizeof(void*) / sizeof(uint32_t);
       )
       VMCASE(OP_STARTMSG,
-        CHECK_SUSPEND(upb_sink_startmsg(&d->top->sink));
+        CHECK_SUSPEND(upb_sink_startmsg(d->top->sink));
       )
       VMCASE(OP_ENDMSG,
-        CHECK_SUSPEND(upb_sink_endmsg(&d->top->sink, d->status));
+        CHECK_SUSPEND(upb_sink_endmsg(d->top->sink, d->status));
       )
       VMCASE(OP_STARTSEQ,
         upb_pbdecoder_frame *outer = outer_frame(d);
-        CHECK_SUSPEND(upb_sink_startseq(&outer->sink, arg, &d->top->sink));
+        CHECK_SUSPEND(upb_sink_startseq(outer->sink, arg, &d->top->sink));
       )
       VMCASE(OP_ENDSEQ,
-        CHECK_SUSPEND(upb_sink_endseq(&d->top->sink, arg));
+        CHECK_SUSPEND(upb_sink_endseq(d->top->sink, arg));
       )
       VMCASE(OP_STARTSUBMSG,
         upb_pbdecoder_frame *outer = outer_frame(d);
-        CHECK_SUSPEND(upb_sink_startsubmsg(&outer->sink, arg, &d->top->sink));
+        CHECK_SUSPEND(upb_sink_startsubmsg(outer->sink, arg, &d->top->sink));
       )
       VMCASE(OP_ENDSUBMSG,
-        CHECK_SUSPEND(upb_sink_endsubmsg(&d->top->sink, arg));
+        CHECK_SUSPEND(upb_sink_endsubmsg(d->top->sink, arg));
       )
       VMCASE(OP_STARTSTR,
         uint32_t len = delim_remaining(d);
         upb_pbdecoder_frame *outer = outer_frame(d);
-        CHECK_SUSPEND(upb_sink_startstr(&outer->sink, arg, len, &d->top->sink));
+        CHECK_SUSPEND(upb_sink_startstr(outer->sink, arg, len, &d->top->sink));
         if (len == 0) {
           d->pc++;  /* Skip OP_STRING. */
         }
       )
       VMCASE(OP_STRING,
         uint32_t len = curbufleft(d);
-        size_t n = upb_sink_putstring(&d->top->sink, arg, d->ptr, len, handle);
+        size_t n = upb_sink_putstring(d->top->sink, arg, d->ptr, len, handle);
         if (n > len) {
           if (n > delim_remaining(d)) {
             seterr(d, "Tried to skip past end of string.");
@@ -790,7 +790,7 @@ size_t run_decoder_vm(upb_pbdecoder *d, const mgroup *group,
         }
       )
       VMCASE(OP_ENDSTR,
-        CHECK_SUSPEND(upb_sink_endstr(&d->top->sink, arg));
+        CHECK_SUSPEND(upb_sink_endstr(d->top->sink, arg));
       )
       VMCASE(OP_PUSHTAGDELIM,
         CHECK_SUSPEND(pushtagdelim(d, arg));
diff --git a/upb/pb/encoder.c b/upb/pb/encoder.c
index 722cc5b..2da34db 100644
--- a/upb/pb/encoder.c
+++ b/upb/pb/encoder.c
@@ -127,7 +127,7 @@ struct upb_pb_encoder {
 
 /* TODO(haberman): handle pushback */
 static void putbuf(upb_pb_encoder *e, const char *buf, size_t len) {
-  size_t n = upb_bytessink_putbuf(&e->output_, e->subc, buf, len, NULL);
+  size_t n = upb_bytessink_putbuf(e->output_, e->subc, buf, len, NULL);
   UPB_ASSERT(n == len);
 }
 
@@ -353,7 +353,7 @@ static bool startmsg(void *c, const void *hd) {
   upb_pb_encoder *e = c;
   UPB_UNUSED(hd);
   if (e->depth++ == 0) {
-    upb_bytessink_start(&e->output_, 0, &e->subc);
+    upb_bytessink_start(e->output_, 0, &e->subc);
   }
   return true;
 }
@@ -363,7 +363,7 @@ static bool endmsg(void *c, const void *hd, upb_status *status) {
   UPB_UNUSED(hd);
   UPB_UNUSED(status);
   if (--e->depth == 0) {
-    upb_bytessink_end(&e->output_);
+    upb_bytessink_end(e->output_);
   }
   return true;
 }
diff --git a/upb/pb/textprinter.c b/upb/pb/textprinter.c
index 91d0d55..934130e 100644
--- a/upb/pb/textprinter.c
+++ b/upb/pb/textprinter.c
@@ -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:
diff --git a/upb/sink.c b/upb/sink.c
index 7a7eeb4..d55d258 100644
--- a/upb/sink.c
+++ b/upb/sink.c
@@ -6,12 +6,12 @@ bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink sink) {
   bool ret;
   upb_bufhandle handle = UPB_BUFHANDLE_INIT;
   handle.buf = buf;
-  ret = upb_bytessink_start(&sink, len, &subc);
+  ret = upb_bytessink_start(sink, len, &subc);
   if (ret && len != 0) {
-    ret = (upb_bytessink_putbuf(&sink, subc, buf, len, &handle) >= len);
+    ret = (upb_bytessink_putbuf(sink, subc, buf, len, &handle) >= len);
   }
   if (ret) {
-    ret = upb_bytessink_end(&sink);
+    ret = upb_bytessink_end(sink);
   }
   return ret;
 }
diff --git a/upb/sink.h b/upb/sink.h
index d93d966..e41feae 100644
--- a/upb/sink.h
+++ b/upb/sink.h
@@ -38,16 +38,16 @@ typedef struct {
   void *closure;
 } upb_sink;
 
-#define PUTVAL(type, ctype)                                            \
-  UPB_INLINE bool upb_sink_put##type(upb_sink *s, upb_selector_t sel,  \
-                                     ctype val) {                      \
-    typedef upb_##type##_handlerfunc functype;                         \
-    functype *func;                                                    \
-    const void *hd;                                                    \
-    if (!s->handlers) return true;                                     \
-    func = (functype *)upb_handlers_gethandler(s->handlers, sel, &hd); \
-    if (!func) return true;                                            \
-    return func(s->closure, hd, val);                                  \
+#define PUTVAL(type, ctype)                                           \
+  UPB_INLINE bool upb_sink_put##type(upb_sink s, upb_selector_t sel,  \
+                                     ctype val) {                     \
+    typedef upb_##type##_handlerfunc functype;                        \
+    functype *func;                                                   \
+    const void *hd;                                                   \
+    if (!s.handlers) return true;                                     \
+    func = (functype *)upb_handlers_gethandler(s.handlers, sel, &hd); \
+    if (!func) return true;                                           \
+    return func(s.closure, hd, val);                                  \
   }
 
 PUTVAL(int32,  int32_t)
@@ -64,134 +64,134 @@ UPB_INLINE void upb_sink_reset(upb_sink *s, const upb_handlers *h, void *c) {
   s->closure = c;
 }
 
-UPB_INLINE size_t upb_sink_putstring(upb_sink *s, upb_selector_t sel,
+UPB_INLINE size_t upb_sink_putstring(upb_sink s, upb_selector_t sel,
                                      const char *buf, size_t n,
                                      const upb_bufhandle *handle) {
   typedef upb_string_handlerfunc func;
   func *handler;
   const void *hd;
-  if (!s->handlers) return n;
-  handler = (func *)upb_handlers_gethandler(s->handlers, sel, &hd);
+  if (!s.handlers) return n;
+  handler = (func *)upb_handlers_gethandler(s.handlers, sel, &hd);
 
   if (!handler) return n;
-  return handler(s->closure, hd, buf, n, handle);
+  return handler(s.closure, hd, buf, n, handle);
 }
 
-UPB_INLINE bool upb_sink_putunknown(upb_sink *s, const char *buf, size_t n) {
+UPB_INLINE bool upb_sink_putunknown(upb_sink s, const char *buf, size_t n) {
   typedef upb_unknown_handlerfunc func;
   func *handler;
   const void *hd;
-  if (!s->handlers) return true;
+  if (!s.handlers) return true;
   handler =
-      (func *)upb_handlers_gethandler(s->handlers, UPB_UNKNOWN_SELECTOR, &hd);
+      (func *)upb_handlers_gethandler(s.handlers, UPB_UNKNOWN_SELECTOR, &hd);
 
   if (!handler) return n;
-  return handler(s->closure, hd, buf, n);
+  return handler(s.closure, hd, buf, n);
 }
 
-UPB_INLINE bool upb_sink_startmsg(upb_sink *s) {
+UPB_INLINE bool upb_sink_startmsg(upb_sink s) {
   typedef upb_startmsg_handlerfunc func;
   func *startmsg;
   const void *hd;
-  if (!s->handlers) return true;
+  if (!s.handlers) return true;
   startmsg =
-      (func *)upb_handlers_gethandler(s->handlers, UPB_STARTMSG_SELECTOR, &hd);
+      (func *)upb_handlers_gethandler(s.handlers, UPB_STARTMSG_SELECTOR, &hd);
 
   if (!startmsg) return true;
-  return startmsg(s->closure, hd);
+  return startmsg(s.closure, hd);
 }
 
-UPB_INLINE bool upb_sink_endmsg(upb_sink *s, upb_status *status) {
+UPB_INLINE bool upb_sink_endmsg(upb_sink s, upb_status *status) {
   typedef upb_endmsg_handlerfunc func;
   func *endmsg;
   const void *hd;
-  if (!s->handlers) return true;
+  if (!s.handlers) return true;
   endmsg =
-      (func *)upb_handlers_gethandler(s->handlers, UPB_ENDMSG_SELECTOR, &hd);
+      (func *)upb_handlers_gethandler(s.handlers, UPB_ENDMSG_SELECTOR, &hd);
 
   if (!endmsg) return true;
-  return endmsg(s->closure, hd, status);
+  return endmsg(s.closure, hd, status);
 }
 
-UPB_INLINE bool upb_sink_startseq(upb_sink *s, upb_selector_t sel,
+UPB_INLINE bool upb_sink_startseq(upb_sink s, upb_selector_t sel,
                                   upb_sink *sub) {
   typedef upb_startfield_handlerfunc func;
   func *startseq;
   const void *hd;
-  sub->closure = s->closure;
-  sub->handlers = s->handlers;
-  if (!s->handlers) return true;
-  startseq = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+  sub->closure = s.closure;
+  sub->handlers = s.handlers;
+  if (!s.handlers) return true;
+  startseq = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
 
   if (!startseq) return true;
-  sub->closure = startseq(s->closure, hd);
+  sub->closure = startseq(s.closure, hd);
   return sub->closure ? true : false;
 }
 
-UPB_INLINE bool upb_sink_endseq(upb_sink *s, upb_selector_t sel) {
+UPB_INLINE bool upb_sink_endseq(upb_sink s, upb_selector_t sel) {
   typedef upb_endfield_handlerfunc func;
   func *endseq;
   const void *hd;
-  if (!s->handlers) return true;
-  endseq = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+  if (!s.handlers) return true;
+  endseq = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
 
   if (!endseq) return true;
-  return endseq(s->closure, hd);
+  return endseq(s.closure, hd);
 }
 
-UPB_INLINE bool upb_sink_startstr(upb_sink *s, upb_selector_t sel,
+UPB_INLINE bool upb_sink_startstr(upb_sink s, upb_selector_t sel,
                                   size_t size_hint, upb_sink *sub) {
   typedef upb_startstr_handlerfunc func;
   func *startstr;
   const void *hd;
-  sub->closure = s->closure;
-  sub->handlers = s->handlers;
-  if (!s->handlers) return true;
-  startstr = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+  sub->closure = s.closure;
+  sub->handlers = s.handlers;
+  if (!s.handlers) return true;
+  startstr = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
 
   if (!startstr) return true;
-  sub->closure = startstr(s->closure, hd, size_hint);
+  sub->closure = startstr(s.closure, hd, size_hint);
   return sub->closure ? true : false;
 }
 
-UPB_INLINE bool upb_sink_endstr(upb_sink *s, upb_selector_t sel) {
+UPB_INLINE bool upb_sink_endstr(upb_sink s, upb_selector_t sel) {
   typedef upb_endfield_handlerfunc func;
   func *endstr;
   const void *hd;
-  if (!s->handlers) return true;
-  endstr = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+  if (!s.handlers) return true;
+  endstr = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
 
   if (!endstr) return true;
-  return endstr(s->closure, hd);
+  return endstr(s.closure, hd);
 }
 
-UPB_INLINE bool upb_sink_startsubmsg(upb_sink *s, upb_selector_t sel,
+UPB_INLINE bool upb_sink_startsubmsg(upb_sink s, upb_selector_t sel,
                                      upb_sink *sub) {
   typedef upb_startfield_handlerfunc func;
   func *startsubmsg;
   const void *hd;
-  sub->closure = s->closure;
-  if (!s->handlers) {
+  sub->closure = s.closure;
+  if (!s.handlers) {
     sub->handlers = NULL;
     return true;
   }
-  sub->handlers = upb_handlers_getsubhandlers_sel(s->handlers, sel);
-  startsubmsg = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+  sub->handlers = upb_handlers_getsubhandlers_sel(s.handlers, sel);
+  startsubmsg = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
 
   if (!startsubmsg) return true;
-  sub->closure = startsubmsg(s->closure, hd);
+  sub->closure = startsubmsg(s.closure, hd);
   return sub->closure ? true : false;
 }
 
-UPB_INLINE bool upb_sink_endsubmsg(upb_sink *s, upb_selector_t sel) {
+UPB_INLINE bool upb_sink_endsubmsg(upb_sink s, upb_selector_t sel) {
   typedef upb_endfield_handlerfunc func;
   func *endsubmsg;
   const void *hd;
-  if (!s->handlers) return true;
-  endsubmsg = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+  if (!s.handlers) return true;
+  endsubmsg = (func*)upb_handlers_gethandler(s.handlers, sel, &hd);
 
-  if (!endsubmsg) return s->closure;
-  return endsubmsg(s->closure, hd);
+  if (!endsubmsg) return s.closure;
+  return endsubmsg(s.closure, hd);
 }
 
 #ifdef __cplusplus
@@ -288,40 +288,40 @@ class upb::Sink {
    *   // ...
    *   sink->EndMessage(&status);
    *   sink->EndSubMessage(endsubmsg_selector); */
-  bool StartMessage() { return upb_sink_startmsg(&sink_); }
+  bool StartMessage() { return upb_sink_startmsg(sink_); }
   bool EndMessage(upb_status *status) {
-    return upb_sink_endmsg(&sink_, 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
    * calls to StartSequence()/EndSequence(). */
   bool PutInt32(HandlersPtr::Selector s, int32_t val) {
-    return upb_sink_putint32(&sink_, s, val);
+    return upb_sink_putint32(sink_, s, val);
   }
 
   bool PutInt64(HandlersPtr::Selector s, int64_t val) {
-    return upb_sink_putint64(&sink_, s, val);
+    return upb_sink_putint64(sink_, s, val);
   }
 
   bool PutUInt32(HandlersPtr::Selector s, uint32_t val) {
-    return upb_sink_putuint32(&sink_, s, val);
+    return upb_sink_putuint32(sink_, s, val);
   }
 
   bool PutUInt64(HandlersPtr::Selector s, uint64_t val) {
-    return upb_sink_putuint64(&sink_, s, val);
+    return upb_sink_putuint64(sink_, s, val);
   }
 
   bool PutFloat(HandlersPtr::Selector s, float val) {
-    return upb_sink_putfloat(&sink_, s, val);
+    return upb_sink_putfloat(sink_, s, val);
   }
 
   bool PutDouble(HandlersPtr::Selector s, double val) {
-    return upb_sink_putdouble(&sink_, s, val);
+    return upb_sink_putdouble(sink_, s, val);
   }
 
   bool PutBool(HandlersPtr::Selector s, bool val) {
-    return upb_sink_putbool(&sink_, s, val);
+    return upb_sink_putbool(sink_, s, val);
   }
 
   /* Putting of string/bytes values.  Each string can consist of zero or more
@@ -331,18 +331,18 @@ class upb::Sink {
    * The sub-sink must be used for any/all PutStringBuffer() calls. */
   bool StartString(HandlersPtr::Selector s, size_t size_hint, Sink* sub) {
     upb_sink sub_c;
-    bool ret = upb_sink_startstr(&sink_, s, size_hint, &sub_c);
+    bool ret = upb_sink_startstr(sink_, s, size_hint, &sub_c);
     *sub = sub_c;
     return ret;
   }
 
   size_t PutStringBuffer(HandlersPtr::Selector s, const char *buf, size_t len,
                          const upb_bufhandle *handle) {
-    return upb_sink_putstring(&sink_, s, buf, len, handle);
+    return upb_sink_putstring(sink_, s, buf, len, handle);
   }
 
   bool EndString(HandlersPtr::Selector s) {
-    return upb_sink_endstr(&sink_, s);
+    return upb_sink_endstr(sink_, s);
   }
 
   /* For submessage fields.
@@ -352,13 +352,13 @@ class upb::Sink {
    * submessage. */
   bool StartSubMessage(HandlersPtr::Selector s, Sink* sub) {
     upb_sink sub_c;
-    bool ret = upb_sink_startsubmsg(&sink_, s, &sub_c);
+    bool ret = upb_sink_startsubmsg(sink_, s, &sub_c);
     *sub = sub_c;
     return ret;
   }
 
   bool EndSubMessage(HandlersPtr::Selector s) {
-    return upb_sink_endsubmsg(&sink_, s);
+    return upb_sink_endsubmsg(sink_, s);
   }
 
   /* For repeated fields of any type, the sequence of values must be wrapped in
@@ -369,13 +369,13 @@ class upb::Sink {
    * sequence. */
   bool StartSequence(HandlersPtr::Selector s, Sink* sub) {
     upb_sink sub_c;
-    bool ret = upb_sink_startseq(&sink_, s, &sub_c);
+    bool ret = upb_sink_startseq(sink_, s, &sub_c);
     *sub = sub_c;
     return ret;
   }
 
   bool EndSequence(HandlersPtr::Selector s) {
-    return upb_sink_endseq(&sink_, s);
+    return upb_sink_endseq(sink_, s);
   }
 
   /* Copy and assign specifically allowed.
@@ -396,49 +396,49 @@ typedef struct {
   void *closure;
 } upb_bytessink ;
 
-UPB_INLINE void upb_bytessink_reset(upb_bytessink *s, const upb_byteshandler *h,
+UPB_INLINE void upb_bytessink_reset(upb_bytessink* s, const upb_byteshandler *h,
                                     void *closure) {
   s->handler = h;
   s->closure = closure;
 }
 
-UPB_INLINE bool upb_bytessink_start(upb_bytessink *s, size_t size_hint,
+UPB_INLINE bool upb_bytessink_start(upb_bytessink s, size_t size_hint,
                                     void **subc) {
   typedef upb_startstr_handlerfunc func;
   func *start;
-  *subc = s->closure;
-  if (!s->handler) return true;
-  start = (func *)s->handler->table[UPB_STARTSTR_SELECTOR].func;
+  *subc = s.closure;
+  if (!s.handler) return true;
+  start = (func *)s.handler->table[UPB_STARTSTR_SELECTOR].func;
 
   if (!start) return true;
-  *subc = start(s->closure,
-                s->handler->table[UPB_STARTSTR_SELECTOR].attr.handler_data,
+  *subc = start(s.closure,
+                s.handler->table[UPB_STARTSTR_SELECTOR].attr.handler_data,
                 size_hint);
   return *subc != NULL;
 }
 
-UPB_INLINE size_t upb_bytessink_putbuf(upb_bytessink *s, void *subc,
+UPB_INLINE size_t upb_bytessink_putbuf(upb_bytessink s, void *subc,
                                        const char *buf, size_t size,
                                        const upb_bufhandle* handle) {
   typedef upb_string_handlerfunc func;
   func *putbuf;
-  if (!s->handler) return true;
-  putbuf = (func *)s->handler->table[UPB_STRING_SELECTOR].func;
+  if (!s.handler) return true;
+  putbuf = (func *)s.handler->table[UPB_STRING_SELECTOR].func;
 
   if (!putbuf) return true;
-  return putbuf(subc, s->handler->table[UPB_STRING_SELECTOR].attr.handler_data,
+  return putbuf(subc, s.handler->table[UPB_STRING_SELECTOR].attr.handler_data,
                 buf, size, handle);
 }
 
-UPB_INLINE bool upb_bytessink_end(upb_bytessink *s) {
+UPB_INLINE bool upb_bytessink_end(upb_bytessink s) {
   typedef upb_endfield_handlerfunc func;
   func *end;
-  if (!s->handler) return true;
-  end = (func *)s->handler->table[UPB_ENDSTR_SELECTOR].func;
+  if (!s.handler) return true;
+  end = (func *)s.handler->table[UPB_ENDSTR_SELECTOR].func;
 
   if (!end) return true;
-  return end(s->closure,
-             s->handler->table[UPB_ENDSTR_SELECTOR].attr.handler_data);
+  return end(s.closure,
+             s.handler->table[UPB_ENDSTR_SELECTOR].attr.handler_data);
 }
 
 #ifdef __cplusplus
@@ -463,7 +463,7 @@ class upb::BytesSink {
    * TODO(haberman): once the Handlers know the expected closure type, verify
    * that T matches it. */
   template <class T> BytesSink(const upb_byteshandler* handler, T* closure) {
-    upb_bytessink_reset(&sink_, handler, closure);
+    upb_bytessink_reset(sink_, handler, closure);
   }
 
   /* Resets the value of the sink. */
@@ -472,16 +472,16 @@ class upb::BytesSink {
   }
 
   bool Start(size_t size_hint, void **subc) {
-    return upb_bytessink_start(&sink_, size_hint, subc);
+    return upb_bytessink_start(sink_, size_hint, subc);
   }
 
   size_t PutBuffer(void *subc, const char *buf, size_t len,
                    const upb_bufhandle *handle) {
-    return upb_bytessink_putbuf(&sink_, subc, buf, len, handle);
+    return upb_bytessink_putbuf(sink_, subc, buf, len, handle);
   }
 
   bool End() {
-    return upb_bytessink_end(&sink_);
+    return upb_bytessink_end(sink_);
   }
 
  private:
-- 
cgit v1.2.3