legacy-libs/grpc/deps/grpc/third_party/upb/upb/msg.c

   1
   2 #include "upb/msg.h"
   3
   4 #include "upb/table.int.h"
   5
   6 #include "upb/port_def.inc"
   7
   8 #define VOIDPTR_AT(msg, ofs) (void*)((char*)msg + (int)ofs)
   9
  10 /* Internal members of a upb_msg.  We can change this without breaking binary
  11  * compatibility.  We put these before the user's data.  The user's upb_msg*
  12  * points after the upb_msg_internal. */
  13
  14 /* Used when a message is not extendable. */
  15 typedef struct {
  16   char *unknown;
  17   size_t unknown_len;
  18   size_t unknown_size;
  19 } upb_msg_internal;
  20
  21 /* Used when a message is extendable. */
  22 typedef struct {
  23   upb_inttable *extdict;
  24   upb_msg_internal base;
  25 } upb_msg_internal_withext;
  26
  27 static int upb_msg_internalsize(const upb_msglayout *l) {
  28   return sizeof(upb_msg_internal) - l->extendable * sizeof(void *);
  29 }
  30
  31 static size_t upb_msg_sizeof(const upb_msglayout *l) {
  32   return l->size + upb_msg_internalsize(l);
  33 }
  34
  35 static upb_msg_internal *upb_msg_getinternal(upb_msg *msg) {
  36   return VOIDPTR_AT(msg, -sizeof(upb_msg_internal));
  37 }
  38
  39 static const upb_msg_internal *upb_msg_getinternal_const(const upb_msg *msg) {
  40   return VOIDPTR_AT(msg, -sizeof(upb_msg_internal));
  41 }
  42
  43 static upb_msg_internal_withext *upb_msg_getinternalwithext(
  44     upb_msg *msg, const upb_msglayout *l) {
  45   UPB_ASSERT(l->extendable);
  46   return VOIDPTR_AT(msg, -sizeof(upb_msg_internal_withext));
  47 }
  48
  49 upb_msg *upb_msg_new(const upb_msglayout *l, upb_arena *a) {
  50   upb_alloc *alloc = upb_arena_alloc(a);
  51   void *mem = upb_malloc(alloc, upb_msg_sizeof(l));
  52   upb_msg_internal *in;
  53   upb_msg *msg;
  54
  55   if (!mem) {
  56     return NULL;
  57   }
  58
  59   msg = VOIDPTR_AT(mem, upb_msg_internalsize(l));
  60
  61   /* Initialize normal members. */
  62   memset(msg, 0, l->size);
  63
  64   /* Initialize internal members. */
  65   in = upb_msg_getinternal(msg);
  66   in->unknown = NULL;
  67   in->unknown_len = 0;
  68   in->unknown_size = 0;
  69
  70   if (l->extendable) {
  71     upb_msg_getinternalwithext(msg, l)->extdict = NULL;
  72   }
  73
  74   return msg;
  75 }
  76
  77 upb_array *upb_array_new(upb_arena *a) {
  78   upb_array *ret = upb_arena_malloc(a, sizeof(upb_array));
  79
  80   if (!ret) {
  81     return NULL;
  82   }
  83
  84   ret->data = NULL;
  85   ret->len = 0;
  86   ret->size = 0;
  87
  88   return ret;
  89 }
  90
  91 void upb_msg_addunknown(upb_msg *msg, const char *data, size_t len,
  92                         upb_arena *arena) {
  93   upb_msg_internal *in = upb_msg_getinternal(msg);
  94   if (len > in->unknown_size - in->unknown_len) {
  95     upb_alloc *alloc = upb_arena_alloc(arena);
  96     size_t need = in->unknown_size + len;
  97     size_t newsize = UPB_MAX(in->unknown_size * 2, need);
  98     in->unknown = upb_realloc(alloc, in->unknown, in->unknown_size, newsize);
  99     in->unknown_size = newsize;
 100   }
 101   memcpy(in->unknown + in->unknown_len, data, len);
 102   in->unknown_len += len;
 103 }
 104
 105 const char *upb_msg_getunknown(const upb_msg *msg, size_t *len) {
 106   const upb_msg_internal* in = upb_msg_getinternal_const(msg);
 107   *len = in->unknown_len;
 108   return in->unknown;
 109 }
 110
 111 #undef VOIDPTR_AT