grpc 1.30.1 → 1.40.0

data/third_party/upb/upb/table.int.h

@@ -13,7 +13,7 @@
 ** store pointers or integers of at least 32 bits (upb isn't really useful on
 ** systems where sizeof(void*) < 4).
 **
-** The table must be homogenous (all values of the same type).  In debug
+** The table must be homogeneous (all values of the same type).  In debug
 ** mode, we check this on insert and lookup.
 */
 
@@ -52,19 +52,8 @@ typedef enum {
 
 typedef struct {
   uint64_t val;
-#ifndef NDEBUG
-  /* In debug mode we carry the value type around also so we can check accesses
-   * to be sure the right member is being read. */
-  upb_ctype_t ctype;
-#endif
 } upb_value;
 
-#ifdef NDEBUG
-#define SET_TYPE(dest, val)      UPB_UNUSED(val)
-#else
-#define SET_TYPE(dest, val) dest = val
-#endif
-
 /* Like strdup(), which isn't always available since it's not ANSI C. */
 char *upb_strdup(const char *s, upb_alloc *a);
 /* Variant that works with a length-delimited rather than NULL-delimited string,
@@ -75,15 +64,13 @@ UPB_INLINE char *upb_gstrdup(const char *s) {
   return upb_strdup(s, &upb_alloc_global);
 }
 
-UPB_INLINE void _upb_value_setval(upb_value *v, uint64_t val,
-                                  upb_ctype_t ctype) {
+UPB_INLINE void _upb_value_setval(upb_value *v, uint64_t val) {
   v->val = val;
-  SET_TYPE(v->ctype, ctype);
 }
 
-UPB_INLINE upb_value _upb_value_val(uint64_t val, upb_ctype_t ctype) {
+UPB_INLINE upb_value _upb_value_val(uint64_t val) {
   upb_value ret;
-  _upb_value_setval(&ret, val, ctype);
+  _upb_value_setval(&ret, val);
   return ret;
 }
 
@@ -98,7 +85,6 @@ UPB_INLINE upb_value _upb_value_val(uint64_t val, upb_ctype_t ctype) {
 #define FUNCS(name, membername, type_t, converter, proto_type) \
   UPB_INLINE void upb_value_set ## name(upb_value *val, type_t cval) { \
     val->val = (converter)cval; \
-    SET_TYPE(val->ctype, proto_type); \
   } \
   UPB_INLINE upb_value upb_value_ ## name(type_t val) { \
     upb_value ret; \
@@ -106,7 +92,6 @@ UPB_INLINE upb_value _upb_value_val(uint64_t val, upb_ctype_t ctype) {
     return ret; \
   } \
   UPB_INLINE type_t upb_value_get ## name(upb_value val) { \
-    UPB_ASSERT_DEBUGVAR(val.ctype == proto_type); \
     return (type_t)(converter)val.val; \
   }
 
@@ -124,12 +109,10 @@ FUNCS(fptr,     fptr,         upb_func*,    uintptr_t,  UPB_CTYPE_FPTR)
 
 UPB_INLINE void upb_value_setfloat(upb_value *val, float cval) {
   memcpy(&val->val, &cval, sizeof(cval));
-  SET_TYPE(val->ctype, UPB_CTYPE_FLOAT);
 }
 
 UPB_INLINE void upb_value_setdouble(upb_value *val, double cval) {
   memcpy(&val->val, &cval, sizeof(cval));
-  SET_TYPE(val->ctype, UPB_CTYPE_DOUBLE);
 }
 
 UPB_INLINE upb_value upb_value_float(float cval) {
@@ -164,16 +147,22 @@ UPB_INLINE char *upb_tabstr(upb_tabkey key, uint32_t *len) {
   return mem + sizeof(*len);
 }
 
+UPB_INLINE upb_strview upb_tabstrview(upb_tabkey key) {
+  upb_strview ret;
+  uint32_t len;
+  ret.data = upb_tabstr(key, &len);
+  ret.size = len;
+  return ret;
+}
 
 /* upb_tabval *****************************************************************/
 
-typedef struct {
+typedef struct upb_tabval {
   uint64_t val;
 } upb_tabval;
 
 #define UPB_TABVALUE_EMPTY_INIT  {-1}
 
-
 /* upb_table ******************************************************************/
 
 typedef struct _upb_tabent {
@@ -189,8 +178,8 @@ typedef struct _upb_tabent {
 
 typedef struct {
   size_t count;          /* Number of entries in the hash part. */
-  size_t mask;           /* Mask to turn hash value -> bucket. */
-  upb_ctype_t ctype;     /* Type of all values. */
+  uint32_t mask;         /* Mask to turn hash value -> bucket. */
+  uint32_t max_count;    /* Max count before we hit our load limit. */
   uint8_t size_lg2;      /* Size of the hashtable part is 2^size_lg2 entries. */
 
   /* Hash table entries.
@@ -200,17 +189,6 @@ typedef struct {
    * initialize const hash tables.  Then we cast away const when we have to.
    */
   const upb_tabent *entries;
-
-#ifndef NDEBUG
-  /* This table's allocator.  We make the user pass it in to every relevant
-   * function and only use this to check it in debug mode.  We do this solely
-   * to keep upb_table as small as possible.  This might seem slightly paranoid
-   * but the plan is to use upb_table for all map fields and extension sets in
-   * a forthcoming message representation, so there could be a lot of these.
-   * If this turns out to be too annoying later, we can change it (since this
-   * is an internal-only header file). */
-  upb_alloc *alloc;
-#endif
 } upb_table;
 
 typedef struct {
@@ -224,12 +202,6 @@ typedef struct {
   size_t array_count;       /* Array part number of elements. */
 } upb_inttable;
 
-#define UPB_INTTABLE_INIT(count, mask, ctype, size_lg2, ent, a, asize, acount) \
-  {UPB_TABLE_INIT(count, mask, ctype, size_lg2, ent), a, asize, acount}
-
-#define UPB_EMPTY_INTTABLE_INIT(ctype) \
-  UPB_INTTABLE_INIT(0, 0, ctype, 0, NULL, NULL, 0, 0)
-
 #define UPB_ARRAY_EMPTYENT -1
 
 UPB_INLINE size_t upb_table_size(const upb_table *t) {
@@ -266,7 +238,8 @@ UPB_INLINE bool upb_arrhas(upb_tabval key) {
 /* Initialize and uninitialize a table, respectively.  If memory allocation
  * failed, false is returned that the table is uninitialized. */
 bool upb_inttable_init2(upb_inttable *table, upb_ctype_t ctype, upb_alloc *a);
-bool upb_strtable_init2(upb_strtable *table, upb_ctype_t ctype, upb_alloc *a);
+bool upb_strtable_init2(upb_strtable *table, upb_ctype_t ctype,
+                        size_t expected_size, upb_alloc *a);
 void upb_inttable_uninit2(upb_inttable *table, upb_alloc *a);
 void upb_strtable_uninit2(upb_strtable *table, upb_alloc *a);
 
@@ -275,7 +248,7 @@ UPB_INLINE bool upb_inttable_init(upb_inttable *table, upb_ctype_t ctype) {
 }
 
 UPB_INLINE bool upb_strtable_init(upb_strtable *table, upb_ctype_t ctype) {
-  return upb_strtable_init2(table, ctype, &upb_alloc_global);
+  return upb_strtable_init2(table, ctype, 4, &upb_alloc_global);
 }
 
 UPB_INLINE void upb_inttable_uninit(upb_inttable *table) {
@@ -298,6 +271,7 @@ upb_inttable *upb_inttable_pack(const upb_inttable *t, void *p, size_t *ofs,
                                 size_t size);
 upb_strtable *upb_strtable_pack(const upb_strtable *t, void *p, size_t *ofs,
                                 size_t size);
+void upb_strtable_clear(upb_strtable *t);
 
 /* Inserts the given key into the hashtable with the given value.  The key must
  * not already exist in the hash table.  For string tables, the key must be
@@ -361,15 +335,6 @@ UPB_INLINE bool upb_strtable_remove(upb_strtable *t, const char *key,
  * invalidate iterators. */
 bool upb_inttable_replace(upb_inttable *t, uintptr_t key, upb_value val);
 
-/* Handy routines for treating an inttable like a stack.  May not be mixed with
- * other insert/remove calls. */
-bool upb_inttable_push2(upb_inttable *t, upb_value val, upb_alloc *a);
-upb_value upb_inttable_pop(upb_inttable *t);
-
-UPB_INLINE bool upb_inttable_push(upb_inttable *t, upb_value val) {
-  return upb_inttable_push2(t, val, &upb_alloc_global);
-}
-
 /* Convenience routines for inttables with pointer keys. */
 bool upb_inttable_insertptr2(upb_inttable *t, const void *key, upb_value val,
                              upb_alloc *a);
@@ -399,7 +364,7 @@ UPB_INLINE bool upb_inttable_lookup32(const upb_inttable *t, uint32_t key,
   if (key < t->array_size) {
     upb_tabval arrval = t->array[key];
     if (upb_arrhas(arrval)) {
-      _upb_value_setval(v, arrval.val, t->t.ctype);
+      _upb_value_setval(v, arrval.val);
       return true;
     } else {
       return false;
@@ -409,7 +374,7 @@ UPB_INLINE bool upb_inttable_lookup32(const upb_inttable *t, uint32_t key,
     if (t->t.entries == NULL) return false;
     for (e = upb_getentry(&t->t, upb_inthash(key)); true; e = e->next) {
       if ((uint32_t)e->key == key) {
-        _upb_value_setval(v, e->val.val, t->t.ctype);
+        _upb_value_setval(v, e->val.val);
         return true;
       }
       if (e->next == NULL) return false;
@@ -463,8 +428,7 @@ typedef struct {
 void upb_strtable_begin(upb_strtable_iter *i, const upb_strtable *t);
 void upb_strtable_next(upb_strtable_iter *i);
 bool upb_strtable_done(const upb_strtable_iter *i);
-const char *upb_strtable_iter_key(const upb_strtable_iter *i);
-size_t upb_strtable_iter_keylength(const upb_strtable_iter *i);
+upb_strview upb_strtable_iter_key(const upb_strtable_iter *i);
 upb_value upb_strtable_iter_value(const upb_strtable_iter *i);
 void upb_strtable_iter_setdone(upb_strtable_iter *i);
 bool upb_strtable_iter_isequal(const upb_strtable_iter *i1,
@@ -488,6 +452,10 @@ typedef struct {
   bool array_part;
 } upb_inttable_iter;
 
+UPB_INLINE const upb_tabent *str_tabent(const upb_strtable_iter *i) {
+  return &i->t->t.entries[i->index];
+}
+
 void upb_inttable_begin(upb_inttable_iter *i, const upb_inttable *t);
 void upb_inttable_next(upb_inttable_iter *i);
 bool upb_inttable_done(const upb_inttable_iter *i);

data/third_party/upb/upb/text_encode.c

@@ -0,0 +1,421 @@
+
+#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;
+  _upb_mapsorter sorter;
+} 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 = 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);
+  }
+}
+
+static void txtenc_mapentry(txtenc *e, upb_msgval key, upb_msgval val,
+                            const upb_fielddef *f) {
+  const upb_msgdef *entry = upb_fielddef_msgsubdef(f);
+  const upb_fielddef *key_f = upb_msgdef_field(entry, 0);
+  const upb_fielddef *val_f = upb_msgdef_field(entry, 1);
+  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);
+}
+
+/*
+ * 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) {
+  if (e->options & UPB_TXTENC_NOSORT) {
+    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_mapentry(e, key, val, f);
+    }
+  } else {
+    const upb_msgdef *entry = upb_fielddef_msgsubdef(f);
+    const upb_fielddef *key_f = upb_msgdef_field(entry, 0);
+    _upb_sortedmap sorted;
+    upb_map_entry ent;
+
+    _upb_mapsorter_pushmap(&e->sorter, upb_fielddef_descriptortype(key_f), map,
+                           &sorted);
+    while (_upb_sortedmap_next(&e->sorter, map, &sorted, &ent)) {
+      upb_msgval key, val;
+      memcpy(&key, &ent.k, sizeof(key));
+      memcpy(&val, &ent.v, sizeof(val));
+      txtenc_mapentry(e, key, val, f);
+    }
+    _upb_mapsorter_popmap(&e->sorter, &sorted);
+  }
+}
+
+#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;
+  _upb_mapsorter_init(&e.sorter);
+
+  txtenc_msg(&e, msg, m);
+  _upb_mapsorter_destroy(&e.sorter);
+  return txtenc_nullz(&e, size);
+}

data/third_party/upb/upb/text_encode.h

@@ -0,0 +1,38 @@
+
+#ifndef UPB_TEXTENCODE_H_
+#define UPB_TEXTENCODE_H_
+
+#include "upb/def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  /* When set, prints everything on a single line. */
+  UPB_TXTENC_SINGLELINE = 1,
+
+  /* When set, unknown fields are not printed. */
+  UPB_TXTENC_SKIPUNKNOWN = 2,
+
+  /* When set, maps are *not* sorted (this avoids allocating tmp mem). */
+  UPB_TXTENC_NOSORT = 4
+};
+
+/* Encodes the given |msg| to text format.  The message's reflection is given in
+ * |m|.  The symtab in |symtab| is used to find extensions (if NULL, extensions
+ * will not be printed).
+ *
+ * Output is placed in the given buffer, and always NULL-terminated.  The output
+ * size (excluding NULL) is returned.  This means that a return value >= |size|
+ * implies that the output was truncated.  (These are the same semantics as
+ * snprintf()). */
+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);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* UPB_TEXTENCODE_H_ */