WIP.

8 files changed, 94 insertions, 99 deletions

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