From 8eb2b2a2169af97e5182a5a758b09a6e0e0caf37 Mon Sep 17 00:00:00 2001 From: Joshua Haberman Date: Wed, 31 Aug 2011 14:57:45 -0700 Subject: Revised upb_bytesink, refactored upb_textprinter (untested). --- upb/pb/textprinter.c | 192 +++++++++++++++++++++++++++------------------------ 1 file changed, 103 insertions(+), 89 deletions(-) (limited to 'upb/pb') 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); } -- cgit v1.2.3