Lines Matching defs:data
416 d->limit = val.data + val.size;
417 decode_msg(d, val.data, submsg, subl);
499 memcpy(mem, val.str_val.data, count << op);
508 const char *ptr = val.str_val.data;
663 val.str_val.data = ptr;
781 /* We want previous data at the end, realloc() put it at the beginning. */
803 static bool upb_put_bytes(upb_encstate *e, const void *data, size_t len) {
806 memcpy(e->ptr, data, len);
864 const char* data = _upb_array_constptr(arr);
865 const char* ptr = data + bytes - elem_size;
869 if (ptr == data) break;
874 return upb_put_bytes(e, data, bytes) && upb_put_varint(e, bytes);
926 return upb_put_bytes(e, view.data, view.size) &&
1022 CHK(upb_put_bytes(e, ptr->data, ptr->size) &&
1082 map->key_size == UPB_MAPTYPE_STRING ? (void *)&key : key.data;
1242 bool _upb_msg_addunknown(upb_msg *msg, const char *data, size_t len,
1254 memcpy(in->unknown + in->unknown_len, data, len);
1274 arr->data = tag_arrptr(NULL, _upb_fieldtype_to_sizelg2[type]);
1283 int elem_size_lg2 = arr->data & 7;
1298 arr->data = tag_arrptr(ptr, elem_size_lg2);
1334 char *data;
1338 data = _upb_array_ptr(arr);
1339 memcpy(data + (elem << lg2), value, 1 << lg2);
1401 /* Always null-terminate, even if binary data; but don't rely on the input to
1665 &new_table, key.data, key.size,
1737 key.data = upb_tabstr(str_tabent(i)->key, &len);
2088 const uint8_t * data = (const uint8_t *)key;
2091 memcpy(&k, data, sizeof(k));
2100 data += 4;
2106 case 3: h ^= data[2] << 16;
2107 case 2: h ^= data[1] << 8;
2108 case 1: h ^= data[0]; h *= m;
2133 const uint8_t * data = (const uint8_t *)key;
2135 uint8_t align = (uintptr_t)data & 3;
2144 case 1: t |= data[2] << 16;
2145 case 2: t |= data[1] << 8;
2146 case 3: t |= data[0];
2151 data += 4-align;
2162 d = *(uint32_t *)data;
2171 data += 4;
2175 /* Handle leftover data in temp registers */
2183 case 3: d |= data[2] << 16;
2184 case 2: d |= data[1] << 8;
2185 case 1: d |= data[0];
2191 data += align;
2198 case 3: h ^= data[2] << 16;
2199 case 2: h ^= data[1] << 8;
2200 case 1: h ^= data[0]; h *= m;
2204 case 3: d |= data[2] << 16;
2205 case 2: d |= data[1] << 8;
2206 case 1: d |= data[0];
2218 uint32_t k = *(uint32_t *)data;
2222 data += 4;
2230 case 3: h ^= data[2] << 16;
2231 case 2: h ^= data[1] << 8;
2232 case 1: h ^= data[0]; h *= m;
2394 memcpy(ret, ptr, oldsize); /* Preserve existing data. */
2977 char str[1]; /* Null-terminated string data follows. */
2980 static str_t *newstr(upb_alloc *alloc, const char *data, size_t len) {
2984 memcpy(ret->str, data, len);
3121 const char *str = name.data;
3382 return upb_strtable_iter_key(iter).data;
3947 /* Allocate data offsets in three stages:
4012 * and space for the actual data. */
4067 upb_alloc *tmp; /* Alloc for addtab and any other tmp data. */
4074 return upb_strdup2(view.data, view.size, ctx->alloc);
4082 return streql2(view.data, view.size, b);
4094 memcpy(&ret[n + 1], name.data, name.size);
4167 if(sym.data[0] == '.') {
4171 if (!upb_strtable_lookup2(t, sym.data + 1, sym.size - 1, &v)) {
4180 f->full_name, sym.data);
4201 upb_status_seterrf(ctx->status, "couldn't resolve name '%s'", sym.data);
4221 CHK_OOM(upb_strtable_insert3(&m->ntof, name.data, name.size, v, ctx->alloc));
4419 upb_strtable_insert3(&m->ntof, name.data, name.size, field_v, alloc));
4498 CHK(upb_strtable_insert3(&oneof->ntof, name.data, name.size, v, alloc));
4749 if (!parse_default(ctx, defaultval.data, defaultval.size, f)) {
4848 if (!upb_strtable_lookup2(&ctx->symtab->files, dep_name.data,
4915 CHK_OOM(upb_strtable_insert3(&s->syms, key.data, key.size, value, alloc));
5078 init->descriptor.data, init->descriptor.size, arena);
5229 val.str_val.data = upb_fielddef_defaultstr(f, &val.str_val.size);
5298 test.str_val.data = NULL;
5332 const char* data = _upb_array_constptr(arr);
5333 int lg2 = arr->data & 7;
5335 memcpy(&ret, data + (i << lg2), 1 << lg2);
5340 char* data = _upb_array_ptr(arr);
5341 int lg2 = arr->data & 7;
5343 memcpy(data + (i << lg2), &val, 1 << lg2);
7109 * indicating how many bytes can be skipped over before passing actual data
7120 /* Skipped data is all in current buffer, and more is still available. */
7125 /* Skipped data extends beyond currently available buffers. */
7293 /* Buffer has enough data to satisfy. */
7449 uint64_t data = 0;
7451 size_t read = peekbytes(d, &data, bytes);
7452 if (read == bytes && data == expected) {
7454 int32_t ok = getbytes(d, &data, read);
7457 } else if (read < bytes && memcmp(&data, &expected, read) == 0) {
7575 * we need to back up to, so that when we're done skipping unknown data we
7644 /* Technically, we are losing data if we see a 32-bit varint that is not
7645 * properly sign-extended. We could detect this and error about the data
7835 seterr(d, "Unexpected EOF: decoder still has buffered unparsed data");
7840 seterr(d, "Unexpected EOF inside skipped data");
7998 ** 1. buffer all submessage data in a temporary buffer, then copy it exactly
8001 ** 2. attempt to buffer data directly into the output buffer, estimating how
8033 ** The strategy is to buffer the segments of data that do *not* depend on
8036 ** alternating the writing of lengths with memcpy() of the rest of the data.
8042 /* The output buffer is divided into segments; a segment is a string of data
8173 static bool encode_bytes(upb_pb_encoder *e, const void *data, size_t len) {
8178 memcpy(e->ptr, data, len);
8195 * not yet known. All data will be buffered until the length is known.
8240 * regions, we can now emit all of the buffered data we accumulated. */
8247 /* All lengths are now available, emit all buffered data. */
8639 /* Flush remaining data. */
9169 * and bools) that the parsed field should be serialized as binary data or
9219 /* Multi-part text data. See details in parser.rl. */
9581 /* Logically appends the given data to the append buffer.
9613 /* Returns a pointer to the data accumulated since the last accumulate_clear()
9623 /* Mult-part text data ********************************************************/
9625 /* When we have text data in the input, it can often come in multiple segments.
9626 * For example, there may be some raw string data followed by an escape
9639 /* We are not currently processing multipart data. */
9642 /* We are processing multipart data by accumulating it into a contiguous
9646 /* We are processing multipart data by pushing each part directly to the
9651 /* Start a multi-part text value where we accumulate the data for processing at
9659 /* Start a multi-part text value where we immediately push text data to a string
10215 /* For STRING fields we push data directly to the handlers as it is
11235 /* Well known types data is represented as value field. */
11246 upb_status_seterrmsg(p->status, "invalid data for well known type.");
11258 upb_status_seterrmsg(p->status, "Invalid data for well known type.");
12643 char data[64]; \
12644 size_t length = fmt_func(val, data, sizeof(data)); \
12647 print_data(p, data, length); \
12668 char data[64]; \
12669 size_t length = fmt_func(val, data, sizeof(data)); \
12672 print_data(p, data, length); \
12850 char data[16000];
12851 const char *limit = data + sizeof(data);
12853 char *to = data;
12864 bytes = to - data;
12865 putstring(p, data, bytes);
12866 to = data;
12898 bytes = to - data;
12899 putstring(p, data, bytes);
13025 * value data in it as key and value handlers are called, and then print the