blob: 7c99228131e27f65c4547c7c73b133af4e2b2788 [file] [log] [blame]
#include "upb/text_encode.h"
#include <ctype.h>
#include <float.h>
#include <inttypes.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "upb/reflection.h"
#include "upb/port_def.inc"
typedef struct {
char *buf, *ptr, *end;
size_t overflow;
int indent_depth;
int options;
const upb_symtab *ext_pool;
} txtenc;
static void txtenc_msg(txtenc *e, const upb_msg *msg, const upb_msgdef *m);
static void txtenc_putbytes(txtenc *e, const void *data, size_t len) {
size_t have = e->end - e->ptr;
if (UPB_LIKELY(have >= len)) {
memcpy(e->ptr, data, len);
e->ptr += len;
} else {
if (have) memcpy(e->ptr, data, have);
e->ptr += have;
e->overflow += (len - have);
}
}
static void txtenc_putstr(txtenc *e, const char *str) {
txtenc_putbytes(e, str, strlen(str));
}
static void txtenc_printf(txtenc *e, const char *fmt, ...) {
size_t n;
size_t have = e->end - e->ptr;
va_list args;
va_start(args, fmt);
n = _upb_vsnprintf(e->ptr, have, fmt, args);
va_end(args);
if (UPB_LIKELY(have > n)) {
e->ptr += n;
} else {
e->ptr += have;
e->overflow += (n - have);
}
}
static void txtenc_indent(txtenc *e) {
if ((e->options & UPB_TXTENC_SINGLELINE) == 0) {
int i = e->indent_depth;
while (i-- > 0) {
txtenc_putstr(e, " ");
}
}
}
static void txtenc_endfield(txtenc *e) {
if (e->options & UPB_TXTENC_SINGLELINE) {
txtenc_putstr(e, " ");
} else {
txtenc_putstr(e, "\n");
}
}
static void txtenc_enum(int32_t val, const upb_fielddef *f, txtenc *e) {
const upb_enumdef *e_def = upb_fielddef_enumsubdef(f);
const char *name = upb_enumdef_iton(e_def, val);
if (name) {
txtenc_printf(e, "%s", name);
} else {
txtenc_printf(e, "%" PRId32, val);
}
}
static void txtenc_string(txtenc *e, upb_strview str, bool bytes) {
const char *ptr = str.data;
const char *end = ptr + str.size;
txtenc_putstr(e, "\"");
while (ptr < end) {
switch (*ptr) {
case '\n':
txtenc_putstr(e, "\\n");
break;
case '\r':
txtenc_putstr(e, "\\r");
break;
case '\t':
txtenc_putstr(e, "\\t");
break;
case '\"':
txtenc_putstr(e, "\\\"");
break;
case '\'':
txtenc_putstr(e, "\\'");
break;
case '\\':
txtenc_putstr(e, "\\\\");
break;
default:
if ((bytes || (uint8_t)*ptr < 0x80) && !isprint(*ptr)) {
txtenc_printf(e, "\\%03o", (int)(uint8_t)*ptr);
} else {
txtenc_putbytes(e, ptr, 1);
}
break;
}
ptr++;
}
txtenc_putstr(e, "\"");
}
static void txtenc_field(txtenc *e, upb_msgval val, const upb_fielddef *f) {
txtenc_indent(e);
txtenc_printf(e, "%s: ", upb_fielddef_name(f));
switch (upb_fielddef_type(f)) {
case UPB_TYPE_BOOL:
txtenc_putstr(e, val.bool_val ? "true" : "false");
break;
case UPB_TYPE_FLOAT:
txtenc_printf(e, "%f", val.float_val);
break;
case UPB_TYPE_DOUBLE:
txtenc_printf(e, "%f", val.double_val);
break;
case UPB_TYPE_INT32:
txtenc_printf(e, "%" PRId32, val.int32_val);
break;
case UPB_TYPE_UINT32:
txtenc_printf(e, "%" PRIu32, val.uint32_val);
break;
case UPB_TYPE_INT64:
txtenc_printf(e, "%" PRId64, val.int64_val);
break;
case UPB_TYPE_UINT64:
txtenc_printf(e, "%" PRIu64, val.uint64_val);
break;
case UPB_TYPE_STRING:
txtenc_string(e, val.str_val, false);
break;
case UPB_TYPE_BYTES:
txtenc_string(e, val.str_val, true);
break;
case UPB_TYPE_ENUM:
txtenc_enum(val.int32_val, f, e);
break;
case UPB_TYPE_MESSAGE:
txtenc_putstr(e, "{");
txtenc_endfield(e);
e->indent_depth++;
txtenc_msg(e, val.msg_val, upb_fielddef_msgsubdef(f));
e->indent_depth--;
txtenc_indent(e);
txtenc_putstr(e, "}");
break;
}
txtenc_endfield(e);
}
/*
* Arrays print as simple repeated elements, eg.
*
* foo_field: 1
* foo_field: 2
* foo_field: 3
*/
static void txtenc_array(txtenc *e, const upb_array *arr,
const upb_fielddef *f) {
size_t i;
size_t size = upb_array_size(arr);
for (i = 0; i < size; i++) {
txtenc_field(e, upb_array_get(arr, i), f);
}
}
/*
* Maps print as messages of key/value, etc.
*
* foo_map: {
* key: "abc"
* value: 123
* }
* foo_map: {
* key: "def"
* value: 456
* }
*/
static void txtenc_map(txtenc *e, const upb_map *map, const upb_fielddef *f) {
const upb_msgdef *entry = upb_fielddef_msgsubdef(f);
const upb_fielddef *key_f = upb_msgdef_itof(entry, 1);
const upb_fielddef *val_f = upb_msgdef_itof(entry, 2);
size_t iter = UPB_MAP_BEGIN;
while (upb_mapiter_next(map, &iter)) {
upb_msgval key = upb_mapiter_key(map, iter);
upb_msgval val = upb_mapiter_value(map, iter);
txtenc_indent(e);
txtenc_printf(e, "%s: {", upb_fielddef_name(f));
txtenc_endfield(e);
e->indent_depth++;
txtenc_field(e, key, key_f);
txtenc_field(e, val, val_f);
e->indent_depth--;
txtenc_indent(e);
txtenc_putstr(e, "}");
txtenc_endfield(e);
}
}
#define CHK(x) do { if (!(x)) { return false; } } while(0)
static const char *txtenc_parsevarint(const char *ptr, const char *limit,
uint64_t *val) {
uint8_t byte;
int bitpos = 0;
*val = 0;
do {
CHK(bitpos < 70 && ptr < limit);
byte = *ptr;
*val |= (uint64_t)(byte & 0x7F) << bitpos;
ptr++;
bitpos += 7;
} while (byte & 0x80);
return ptr;
}
/*
* Unknown fields are printed by number.
*
* 1001: 123
* 1002: "hello"
* 1006: 0xdeadbeef
* 1003: {
* 1: 111
* }
*/
static const char *txtenc_unknown(txtenc *e, const char *ptr, const char *end,
int groupnum) {
while (ptr < end) {
uint64_t tag_64;
uint32_t tag;
CHK(ptr = txtenc_parsevarint(ptr, end, &tag_64));
CHK(tag_64 < UINT32_MAX);
tag = (uint32_t)tag_64;
if ((tag & 7) == UPB_WIRE_TYPE_END_GROUP) {
CHK((tag >> 3) == (uint32_t)groupnum);
return ptr;
}
txtenc_indent(e);
txtenc_printf(e, "%d: ", (int)(tag >> 3));
switch (tag & 7) {
case UPB_WIRE_TYPE_VARINT: {
uint64_t val;
CHK(ptr = txtenc_parsevarint(ptr, end, &val));
txtenc_printf(e, "%" PRIu64, val);
break;
}
case UPB_WIRE_TYPE_32BIT: {
uint32_t val;
CHK(end - ptr >= 4);
memcpy(&val, ptr, 4);
ptr += 4;
txtenc_printf(e, "0x%08" PRIu32, val);
break;
}
case UPB_WIRE_TYPE_64BIT: {
uint64_t val;
CHK(end - ptr >= 8);
memcpy(&val, ptr, 8);
ptr += 8;
txtenc_printf(e, "0x%016" PRIu64, val);
break;
}
case UPB_WIRE_TYPE_DELIMITED: {
uint64_t len;
size_t avail = end - ptr;
char *start = e->ptr;
size_t start_overflow = e->overflow;
CHK(ptr = txtenc_parsevarint(ptr, end, &len));
CHK(avail >= len);
/* Speculatively try to parse as message. */
txtenc_putstr(e, "{");
txtenc_endfield(e);
e->indent_depth++;
if (txtenc_unknown(e, ptr, end, -1)) {
e->indent_depth--;
txtenc_indent(e);
txtenc_putstr(e, "}");
} else {
/* Didn't work out, print as raw bytes. */
upb_strview str;
e->indent_depth--;
e->ptr = start;
e->overflow = start_overflow;
str.data = ptr;
str.size = len;
txtenc_string(e, str, true);
}
ptr += len;
break;
}
case UPB_WIRE_TYPE_START_GROUP:
txtenc_putstr(e, "{");
txtenc_endfield(e);
e->indent_depth++;
CHK(ptr = txtenc_unknown(e, ptr, end, tag >> 3));
e->indent_depth--;
txtenc_indent(e);
txtenc_putstr(e, "}");
break;
}
txtenc_endfield(e);
}
return groupnum == -1 ? ptr : NULL;
}
#undef CHK
static void txtenc_msg(txtenc *e, const upb_msg *msg,
const upb_msgdef *m) {
size_t iter = UPB_MSG_BEGIN;
const upb_fielddef *f;
upb_msgval val;
while (upb_msg_next(msg, m, e->ext_pool, &f, &val, &iter)) {
if (upb_fielddef_ismap(f)) {
txtenc_map(e, val.map_val, f);
} else if (upb_fielddef_isseq(f)) {
txtenc_array(e, val.array_val, f);
} else {
txtenc_field(e, val, f);
}
}
if ((e->options & UPB_TXTENC_SKIPUNKNOWN) == 0) {
size_t len;
const char *ptr = upb_msg_getunknown(msg, &len);
char *start = e->ptr;
if (ptr) {
if (!txtenc_unknown(e, ptr, ptr + len, -1)) {
/* Unknown failed to parse, back up and don't print it at all. */
e->ptr = start;
}
}
}
}
size_t txtenc_nullz(txtenc *e, size_t size) {
size_t ret = e->ptr - e->buf + e->overflow;
if (size > 0) {
if (e->ptr == e->end) e->ptr--;
*e->ptr = '\0';
}
return ret;
}
size_t upb_text_encode(const upb_msg *msg, const upb_msgdef *m,
const upb_symtab *ext_pool, int options, char *buf,
size_t size) {
txtenc e;
e.buf = buf;
e.ptr = buf;
e.end = buf + size;
e.overflow = 0;
e.indent_depth = 0;
e.options = options;
e.ext_pool = ext_pool;
txtenc_msg(&e, msg, m);
return txtenc_nullz(&e, size);
}