Revised upb_bytesink, refactored upb_textprinter (untested).

1 files changed, 103 insertions, 89 deletions

diff --git a/upb/pb/textprinter.c b/upb/pb/textprinter.c
index 893953c..37f5699 100644
--- a/upb/pb/textprinter.c
+++ b/upb/pb/textprinter.c
@@ -12,7 +12,7 @@
 #include "upb/pb/textprinter.h"
 
 struct _upb_textprinter {
-  upb_bytesink *bytesink;
+  upb_bytesink *sink;
   int indent_depth;
   bool single_line;
   upb_status status;
@@ -20,11 +20,26 @@ struct _upb_textprinter {
 
 #define CHECK(x) if ((x) < 0) goto err;
 
+static int upb_textprinter_indent(upb_textprinter *p) {
+  if (!p->single_line)
+    CHECK(upb_bytesink_putrepeated(p->sink, ' ', p->indent_depth*2));
+  return 0;
+err:
+  return -1;
+}
+
+static int upb_textprinter_endfield(upb_textprinter *p) {
+  CHECK(upb_bytesink_putc(p->sink, p->single_line ? ' ' : '\n'));
+  return 0;
+err:
+  return -1;
+}
+
 static int upb_textprinter_putescaped(upb_textprinter *p, upb_strref *strref,
                                       bool preserve_utf8) {
   // Based on CEscapeInternal() from Google's protobuf release.
-  // TODO; we could read directly fraom a bytesrc's buffer instead.
-  // TODO; we could write directly into a bytesink's buffer instead.
+  // TODO; we could read directly from a bytesrc's buffer instead.
+  // TODO; we could write strrefs to the sink when possible.
   char dstbuf[4096], *dst = dstbuf, *dstend = dstbuf + sizeof(dstbuf);
   char buf[strref->len], *src = buf;
   char *end = src + strref->len;
@@ -32,12 +47,12 @@ static int upb_textprinter_putescaped(upb_textprinter *p, upb_strref *strref,
 
   // I think hex is prettier and more useful, but proto2 uses octal; should
   // investigate whether it can parse hex also.
-  bool use_hex = false;
+  const bool use_hex = false;
   bool last_hex_escape = false; // true if last output char was \xNN
 
   for (; src < end; src++) {
     if (dstend - dst < 4) {
-      CHECK(upb_bytesink_write(p->bytesink, dstbuf, dst - dstbuf));
+      CHECK(upb_bytesink_write(p->sink, dstbuf, dst - dstbuf));
       dst = dstbuf;
     }
 
@@ -65,108 +80,102 @@ static int upb_textprinter_putescaped(upb_textprinter *p, upb_strref *strref,
     last_hex_escape = is_hex_escape;
   }
   // Flush remaining data.
-  CHECK(upb_bytesink_write(p->bytesink, dst, dst - dstbuf));
+  CHECK(upb_bytesink_write(p->sink, dst, dst - dstbuf));
   return 0;
 err:
   return -1;
 }
 
-static int upb_textprinter_indent(upb_textprinter *p) {
-  if(!p->single_line)
-    for(int i = 0; i < p->indent_depth; i++)
-      CHECK(upb_bytesink_writestr(p->bytesink, "  "));
-  return 0;
-err:
-  return -1;
+#define TYPE(member, fmt) \
+  static upb_flow_t upb_textprinter_put ## member(void *_p, upb_value fval,  \
+                                                  upb_value val) {           \
+    upb_textprinter *p = _p;                                                 \
+    upb_fielddef *f = upb_value_getfielddef(fval);                           \
+    uint64_t start_ofs = upb_bytesink_getoffset(p->sink);                    \
+    CHECK(upb_textprinter_indent(p));                                        \
+    CHECK(upb_bytesink_writestr(p->sink, f->name));                          \
+    CHECK(upb_bytesink_writestr(p->sink, ": "));                             \
+    CHECK(upb_bytesink_printf(p->sink, fmt, upb_value_get ## member(val)));  \
+    CHECK(upb_textprinter_endfield(p));                                      \
+    return UPB_CONTINUE;                                                     \
+  err:                                                                       \
+    upb_bytesink_rewind(p->sink, start_ofs);                                 \
+    return UPB_BREAK;                                                        \
 }
 
-static int upb_textprinter_endfield(upb_textprinter *p) {
-  if(p->single_line) {
-    CHECK(upb_bytesink_writestr(p->bytesink, " "));
+#define STRINGIFY_HELPER(x) #x
+#define STRINGIFY_MACROVAL(x) STRINGIFY_HELPER(x)
+
+TYPE(double, "%." STRINGIFY_MACROVAL(DBL_DIG) "g")
+TYPE(float,  "%." STRINGIFY_MACROVAL(FLT_DIG) "g")
+TYPE(int64,  "%" PRId64)
+TYPE(uint64, "%" PRIu64)
+TYPE(int32,  "%" PRId32)
+TYPE(uint32, "%" PRIu32);
+TYPE(bool,   "%hhu");
+
+// Output a symbolic value from the enum if found, else just print as int32.
+static upb_flow_t upb_textprinter_putenum(void *_p, upb_value fval,
+                                          upb_value val) {
+
+  upb_textprinter *p = _p;
+  uint64_t start_ofs = upb_bytesink_getoffset(p->sink);
+  upb_fielddef *f = upb_value_getfielddef(fval);
+  upb_enumdef *enum_def = upb_downcast_enumdef(f->def);
+  const char *label = upb_enumdef_iton(enum_def, upb_value_getint32(val));
+  if (label) {
+    CHECK(upb_bytesink_writestr(p->sink, label));
   } else {
-    CHECK(upb_bytesink_writestr(p->bytesink, "\n"));
+    CHECK(upb_textprinter_putint32(_p, fval, val));
   }
-  return 0;
+  return UPB_CONTINUE;
 err:
-  return -1;
+  upb_bytesink_rewind(p->sink, start_ofs);
+  return UPB_BREAK;
 }
 
-static upb_flow_t upb_textprinter_value(void *_p, upb_value fval,
-                                        upb_value val) {
+static upb_flow_t upb_textprinter_putstr(void *_p, upb_value fval,
+                                         upb_value val) {
   upb_textprinter *p = _p;
+  uint64_t start_ofs = upb_bytesink_getoffset(p->sink);
   upb_fielddef *f = upb_value_getfielddef(fval);
-  upb_textprinter_indent(p);
-  CHECK(upb_bytesink_printf(p->bytesink, "%s: ", f->name));
-#define CASE(fmtstr, member) \
-    CHECK(upb_bytesink_printf(p->bytesink, fmtstr, upb_value_get ## member(val))); break;
-  switch(f->type) {
-    // TODO: figure out what we should really be doing for these
-    // floating-point formats.
-    case UPB_TYPE(DOUBLE):
-      CHECK(upb_bytesink_printf(p->bytesink, "%.*g", DBL_DIG, upb_value_getdouble(val))); break;
-    case UPB_TYPE(FLOAT):
-      CHECK(upb_bytesink_printf(p->bytesink, "%.*g", FLT_DIG+2, upb_value_getfloat(val))); break;
-    case UPB_TYPE(INT64):
-    case UPB_TYPE(SFIXED64):
-    case UPB_TYPE(SINT64):
-      CASE("%" PRId64, int64)
-    case UPB_TYPE(UINT64):
-    case UPB_TYPE(FIXED64):
-      CASE("%" PRIu64, uint64)
-    case UPB_TYPE(UINT32):
-    case UPB_TYPE(FIXED32):
-      CASE("%" PRIu32, uint32);
-    case UPB_TYPE(ENUM): {
-      upb_enumdef *enum_def = upb_downcast_enumdef(f->def);
-      const char *label = upb_enumdef_iton(enum_def, upb_value_getint32(val));
-      if (label) {
-        // We found a corresponding string for this enum.  Otherwise we fall
-        // through to the int32 code path.
-        CHECK(upb_bytesink_writestr(p->bytesink, label));
-        break;
-      }
-    }
-    case UPB_TYPE(INT32):
-    case UPB_TYPE(SFIXED32):
-    case UPB_TYPE(SINT32):
-      CASE("%" PRId32, int32)
-    case UPB_TYPE(BOOL):
-      CASE("%hhu", bool);
-    case UPB_TYPE(STRING):
-    case UPB_TYPE(BYTES): {
-      CHECK(upb_bytesink_writestr(p->bytesink, "\""));
-      CHECK(upb_textprinter_putescaped(p, upb_value_getstrref(val),
-                                       f->type == UPB_TYPE(STRING)));
-      CHECK(upb_bytesink_writestr(p->bytesink, "\""));
-      break;
-    }
-  }
-  upb_textprinter_endfield(p);
+  CHECK(upb_bytesink_putc(p->sink, '"'));
+  CHECK(upb_textprinter_putescaped(p, upb_value_getstrref(val),
+                                   f->type == UPB_TYPE(STRING)));
+  CHECK(upb_bytesink_putc(p->sink, '"'));
   return UPB_CONTINUE;
 err:
+  upb_bytesink_rewind(p->sink, start_ofs);
   return UPB_BREAK;
 }
 
 static upb_sflow_t upb_textprinter_startsubmsg(void *_p, upb_value fval) {
   upb_textprinter *p = _p;
+  uint64_t start_ofs = upb_bytesink_getoffset(p->sink);
   upb_fielddef *f = upb_value_getfielddef(fval);
-  upb_textprinter_indent(p);
-  bool ret = upb_bytesink_printf(p->bytesink, "%s {", f->name);
-  if (!ret) return UPB_SBREAK;
+  CHECK(upb_textprinter_indent(p));
+  CHECK(upb_bytesink_printf(p->sink, "%s {", f->name));
   if (!p->single_line)
-    upb_bytesink_writestr(p->bytesink, "\n");
+    CHECK(upb_bytesink_putc(p->sink, '\n'));
   p->indent_depth++;
   return UPB_CONTINUE_WITH(_p);
+err:
+  upb_bytesink_rewind(p->sink, start_ofs);
+  return UPB_SBREAK;
 }
 
 static upb_flow_t upb_textprinter_endsubmsg(void *_p, upb_value fval) {
   (void)fval;
   upb_textprinter *p = _p;
+  uint64_t start_ofs = upb_bytesink_getoffset(p->sink);
   p->indent_depth--;
-  upb_textprinter_indent(p);
-  upb_bytesink_writestr(p->bytesink, "}");
-  upb_textprinter_endfield(p);
+  CHECK(upb_textprinter_indent(p));
+  CHECK(upb_bytesink_putc(p->sink, '}'));
+  CHECK(upb_textprinter_endfield(p));
   return UPB_CONTINUE;
+err:
+  upb_bytesink_rewind(p->sink, start_ofs);
+  return UPB_BREAK;
 }
 
 upb_textprinter *upb_textprinter_new() {
@@ -174,26 +183,31 @@ upb_textprinter *upb_textprinter_new() {
   return p;
 }
 
-void upb_textprinter_free(upb_textprinter *p) {
-  free(p);
-}
+void upb_textprinter_free(upb_textprinter *p) { free(p); }
 
 void upb_textprinter_reset(upb_textprinter *p, upb_bytesink *sink,
                            bool single_line) {
-  p->bytesink = sink;
+  p->sink = sink;
   p->single_line = single_line;
   p->indent_depth = 0;
 }
 
+static void upb_textprinter_onfreg(void *c, upb_fhandlers *fh, upb_fielddef *f) {
+  (void)c;
+  upb_fhandlers_setstartsubmsg(fh, &upb_textprinter_startsubmsg);
+  upb_fhandlers_setendsubmsg(fh, &upb_textprinter_endsubmsg);
+#define F(type) &upb_textprinter_put ## type
+  static upb_value_handler *fptrs[] = {NULL, F(double), F(float), F(int64),
+      F(uint64), F(int32), F(uint64), F(uint32), F(bool), F(str),
+      NULL, NULL, F(str), F(uint32), F(enum), F(int32),
+      F(int64), F(int32), F(int64)};
+  upb_fhandlers_setvalue(fh, fptrs[f->type]);
+  upb_value fval;
+  upb_value_setfielddef(&fval, f);
+  upb_fhandlers_setfval(fh, fval);
+}
+
 upb_mhandlers *upb_textprinter_reghandlers(upb_handlers *h, upb_msgdef *m) {
-  upb_handlerset hset = {
-    NULL,  // startmsg
-    NULL,  // endmsg
-    upb_textprinter_value,
-    upb_textprinter_startsubmsg,
-    upb_textprinter_endsubmsg,
-    NULL,  // startseq
-    NULL,  // endseq
-  };
-  return upb_handlers_reghandlerset(h, m, &hset);
+  return upb_handlers_regmsgdef(
+      h, m, NULL, &upb_textprinter_onfreg, NULL);
 }