Lines Matching defs:ptr
333 static const char *decode_msg(upb_decstate *d, const char *ptr, upb_msg *msg,
381 static const char *decode_longvarint64(upb_decstate *d, const char *ptr,
388 if (bitpos >= 70 || ptr == limit) decode_err(d);
389 byte = *ptr;
391 ptr++;
396 return ptr;
400 static const char *decode_varint64(upb_decstate *d, const char *ptr,
402 if (UPB_LIKELY(ptr < limit && (*ptr & 0x80) == 0)) {
403 *val = (uint8_t)*ptr;
404 return ptr + 1;
406 return decode_longvarint64(d, ptr, limit, val);
410 static const char *decode_varint32(upb_decstate *d, const char *ptr,
413 ptr = decode_varint64(d, ptr, limit, &u64);
416 return ptr;
472 static const char *decode_group(upb_decstate *d, const char *ptr,
476 ptr = decode_msg(d, ptr, submsg, subl);
480 return ptr;
483 static const char *decode_togroup(upb_decstate *d, const char *ptr,
487 return decode_group(d, ptr, submsg, subl, field->number);
490 static const char *decode_toarray(upb_decstate *d, const char *ptr,
515 return ptr;
525 return ptr;
533 ptr = decode_togroup(d, ptr, submsg, layout, field);
537 return ptr;
552 return ptr;
560 const char *ptr = val.str_val.data;
561 const char *end = ptr + val.str_val.size;
563 while (ptr < end) {
565 ptr = decode_varint64(d, ptr, end, &elem.uint64_val);
574 if (ptr != end) decode_err(d);
575 return ptr;
618 static const char *decode_tomsg(upb_decstate *d, const char *ptr, upb_msg *msg,
647 ptr = decode_togroup(d, ptr, submsg, layout, field);
672 return ptr;
675 static const char *decode_msg(upb_decstate *d, const char *ptr, upb_msg *msg,
677 while (ptr < d->limit) {
682 const char *field_start = ptr;
686 ptr = decode_varint32(d, ptr, d->limit, &tag);
694 ptr = decode_varint64(d, ptr, d->limit, &val.uint64_val);
699 if (d->limit - ptr < 4) decode_err(d);
700 memcpy(&val, ptr, 4);
701 ptr += 4;
706 if (d->limit - ptr < 8) decode_err(d);
707 memcpy(&val, ptr, 8);
708 ptr += 8;
716 ptr = decode_varint32(d, ptr, d->limit, &size);
717 if (size >= INT32_MAX || (size_t)(d->limit - ptr) < size) {
720 val.str_val.data = ptr;
722 ptr += size;
733 return ptr;
743 ptr = decode_toarray(d, ptr, msg, layout, field, val, op);
749 ptr = decode_tomsg(d, ptr, msg, layout, field, val, op);
757 ptr = decode_group(d, ptr, NULL, NULL, field_number);
760 if (!_upb_msg_addunknown(msg, field_start, ptr - field_start,
768 if (ptr != d->limit) decode_err(d);
769 return ptr;
821 char *buf, *ptr, *limit;
834 size_t new_size = upb_roundup_pow2(bytes + (e->limit - e->ptr));
843 e->ptr = new_buf + new_size - (e->limit - e->ptr);
850 * e->ptr. Returns false if the bytes could not be allocated. */
852 CHK(UPB_LIKELY((size_t)(e->ptr - e->buf) >= bytes) ||
855 e->ptr -= bytes;
863 memcpy(e->ptr, data, len);
881 len = upb_encode_varint(val, e->ptr);
882 start = e->ptr + UPB_PB_VARINT_MAX_LEN - len;
883 memmove(start, e->ptr, len);
884 e->ptr = start;
910 const char* ptr = data + bytes - elem_size;
913 CHK(upb_put_bytes(e, ptr, elem_size) && upb_put_varint(e, tag));
914 if (ptr == data) break;
915 ptr -= elem_size;
1015 const ctype *ptr = start + arr->len; \
1016 size_t pre_len = e->limit - e->ptr; \
1019 ptr--; \
1022 } while (ptr != start); \
1023 if (!tag) CHK(upb_put_varint(e, e->limit - e->ptr - pre_len)); \
1049 VARINT_CASE(uint64_t, *ptr);
1051 VARINT_CASE(uint32_t, *ptr);
1054 VARINT_CASE(int32_t, (int64_t)*ptr);
1056 VARINT_CASE(bool, *ptr);
1058 VARINT_CASE(int32_t, upb_zzencode_32(*ptr));
1060 VARINT_CASE(int64_t, upb_zzencode_64(*ptr));
1064 const upb_strview *ptr = start + arr->len;
1066 ptr--;
1067 CHK(upb_put_bytes(e, ptr->data, ptr->size) &&
1068 upb_put_varint(e, ptr->size) &&
1070 } while (ptr != start);
1075 const void *const*ptr = start + arr->len;
1079 ptr--;
1081 upb_encode_message(e, *ptr, subm, &size) &&
1083 } while (ptr != start);
1088 const void *const*ptr = start + arr->len;
1092 ptr--;
1093 CHK(upb_encode_message(e, *ptr, subm, &size) &&
1096 } while (ptr != start);
1122 size_t pre_len = e->limit - e->ptr;
1131 size = (e->limit - e->ptr) - pre_len;
1143 size_t pre_len = e->limit - e->ptr;
1180 *size = (e->limit - e->ptr) - pre_len;
1190 e.ptr = NULL;
1197 *size = e.limit - e.ptr;
1203 UPB_ASSERT(e.ptr);
1204 return e.ptr;
1230 static uintptr_t tag_arrptr(void* ptr, int elem_size_lg2) {
1232 return (uintptr_t)ptr | elem_size_lg2;
1320 void* ptr = _upb_array_ptr(arr);
1326 ptr = upb_arena_realloc(arena, ptr, old_bytes, new_bytes);
1328 if (!ptr) {
1332 arr->data = tag_arrptr(ptr, elem_size_lg2);
2316 static void *upb_global_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
2321 free(ptr);
2324 return realloc(ptr, size);
2378 static void upb_arena_addblock(upb_arena *a, void *ptr, size_t size) {
2379 mem_block *block = ptr;
2390 a->head.ptr = UPB_PTR_AT(block, memblock_reserve, char);
2408 return (size_t)(h->end - h->ptr) >= size;
2417 static void *upb_arena_doalloc(upb_alloc *alloc, void *ptr, size_t oldsize,
2420 return upb_arena_realloc(a, ptr, oldsize, size);
2469 a->head.ptr = mem;
2488 cleanup_ent *ptr = end - block->cleanups;
2490 for (; ptr < end; ptr++) {
2491 ptr->cleanup(ptr->ud);
3525 upb_strtable syms; /* full_name -> packed def ptr */
3547 static upb_value pack_def(const void *ptr, upb_deftype_t type) {
3548 uintptr_t num = (uintptr_t)ptr | type;
4531 upb_strtable *addtab; /* full_name -> packed def ptr for new defs */
5800 /* Clear string pointer, only size matters (ptr could be non-NULL). */
6008 const char *ptr, *end;
6036 (int)(d->ptr - d->line_begin), msg);
6043 (int)(d->ptr - d->line_begin));
6051 while (d->ptr != d->end) {
6052 switch (*d->ptr) {
6055 d->line_begin = d->ptr;
6060 d->ptr++;
6070 if (d->ptr == d->end || *d->ptr != ch) return false;
6071 d->ptr++;
6076 size_t avail = d->end - d->ptr;
6078 if (avail < len || memcmp(d->ptr, lit, len) != 0) {
6081 d->ptr += len;
6101 switch (*d->ptr) {
6127 jsondec_errf(d, "Unexpected character: '%c'", *d->ptr);
6157 if (*d->ptr == end_ch) return false;
6197 const char *start = d->ptr;
6199 while (d->ptr < d->end) {
6200 if (*d->ptr < '0' || *d->ptr > '9') {
6203 d->ptr++;
6206 return d->ptr != start;
6216 const char *start = d->ptr;
6221 if (*d->ptr == '-') d->ptr++;
6231 if (d->ptr == d->end) goto parse;
6235 if (d->ptr == d->end) goto parse;
6237 if (*d->ptr == 'e' || *d->ptr == 'E') {
6238 d->ptr++;
6239 if (d->ptr == d->end) {
6242 if (*d->ptr == '+' || *d->ptr == '-') {
6243 d->ptr++;
6255 assert(end == d->ptr);
6277 switch (*d->ptr++) {
6303 if (d->end - d->ptr < 4) {
6307 end = d->ptr + 4;
6308 while (d->ptr < end) {
6309 char ch = *d->ptr++;
6385 if (*d->ptr++ != '"') {
6389 while (d->ptr < d->end) {
6390 char ch = *d->ptr++;
6405 if (d->ptr == d->end) goto eof;
6406 if (*d->ptr == 'u') {
6407 d->ptr++;
6418 if ((unsigned char)*d->ptr < 0x20) {
6513 static char *jsondec_partialbase64(jsondec *d, const char *ptr, const char *end,
6517 switch (end - ptr) {
6519 val = jsondec_base64_tablelookup(ptr[0]) << 18 |
6520 jsondec_base64_tablelookup(ptr[1]) << 12;
6525 val = jsondec_base64_tablelookup(ptr[0]) << 18 |
6526 jsondec_base64_tablelookup(ptr[1]) << 12 |
6527 jsondec_base64_tablelookup(ptr[2]) << 6;
6545 const char *ptr = str.data;
6546 const char *end = ptr + str.size;
6547 const char *end4 = ptr + (str.size & -4); /* Round down to multiple of 4. */
6549 for (; ptr < end4; ptr += 4, out += 3) {
6550 int val = jsondec_base64_tablelookup(ptr[0]) << 18 |
6551 jsondec_base64_tablelookup(ptr[1]) << 12 |
6552 jsondec_base64_tablelookup(ptr[2]) << 6 |
6553 jsondec_base64_tablelookup(ptr[3]) << 0;
6557 if (end - ptr == 4 && ptr[3] == '=') {
6558 if (ptr[2] == '=') {
6572 if (ptr < end) {
6574 out = jsondec_partialbase64(d, ptr, end, out);
6583 * long" variants aren't in c89. Also our version allows setting a ptr limit. */
6585 static const char *jsondec_buftouint64(jsondec *d, const char *ptr,
6588 while (ptr < end) {
6589 unsigned ch = *ptr - '0';
6596 ptr++;
6600 return ptr;
6603 static const char *jsondec_buftoint64(jsondec *d, const char *ptr,
6608 if (ptr != end && *ptr == '-') {
6609 ptr++;
6613 ptr = jsondec_buftouint64(d, ptr, end, &u64);
6619 return ptr;
6948 static int jsondec_tsdigits(jsondec *d, const char **ptr, size_t digits,
6951 const char *p = *ptr;
6964 *ptr = end + after_len;
6968 static int jsondec_nanos(jsondec *d, const char **ptr, const char *end) {
6970 const char *p = *ptr;
6980 *ptr = nano_end;
7008 const char *ptr = str.data;
7009 const char *end = ptr + str.size;
7015 int year = jsondec_tsdigits(d, &ptr, 4, "-");
7016 int mon = jsondec_tsdigits(d, &ptr, 2, "-");
7017 int day = jsondec_tsdigits(d, &ptr, 2, "T");
7018 int hour = jsondec_tsdigits(d, &ptr, 2, ":");
7019 int min = jsondec_tsdigits(d, &ptr, 2, ":");
7020 int sec = jsondec_tsdigits(d, &ptr, 2, NULL);
7025 nanos.int32_val = jsondec_nanos(d, &ptr, end);
7032 if (ptr == end) goto malformed;
7034 switch (*ptr++) {
7039 if ((end - ptr) != 5) goto malformed;
7040 ofs = jsondec_tsdigits(d, &ptr, 2, ":00");
7045 if (ptr != end) goto malformed;
7068 const char *ptr = str.data;
7069 const char *end = ptr + str.size;
7072 ptr = jsondec_buftoint64(d, ptr, end, &seconds.int64_val);
7073 nanos.int32_val = jsondec_nanos(d, &ptr, end);
7075 if (end - ptr != 1 || *ptr != 's') {
7185 const char *ptr = buf;
7189 ret.size = end - ptr;
7190 while (ptr < end) {
7191 ret.size += (*ptr >= 'A' && *ptr <= 'Z');
7192 ptr++;
7196 ptr = buf;
7199 while (ptr < end) {
7200 char ch = *ptr++;
7219 const char *ptr = str.data;
7220 const char *end = ptr + str.size;
7223 while (ptr < end) {
7224 const char *elem_end = memchr(ptr, ',', end - ptr);
7226 val.str_val = jsondec_mask(d, ptr, elem_end);
7227 ptr = elem_end + 1;
7229 val.str_val = jsondec_mask(d, ptr, end);
7230 ptr = end;
7259 const char *ptr = end;
7266 while (ptr > type_url.data && *--ptr != '/') {}
7268 if (ptr == type_url.data || ptr == end) {
7272 ptr++;
7273 type_m = upb_symtab_lookupmsg2(d->any_pool, ptr, end - ptr);
7296 const char *start = d->ptr;
7320 const char *saved_ptr = d->ptr;
7324 d->ptr = tmp;
7330 d->ptr = saved_ptr;
7394 d.ptr = buf;
7402 d.line_begin = d.ptr;
7424 char *buf, *ptr, *end;
7464 size_t have = e->end - e->ptr;
7466 memcpy(e->ptr, data, len);
7467 e->ptr += len;
7469 if (have) memcpy(e->ptr, data, have);
7470 e->ptr += have;
7481 size_t have = e->end - e->ptr;
7485 n = _upb_vsnprintf(e->ptr, have, fmt, args);
7489 e->ptr += n;
7491 e->ptr += have;
7589 const unsigned char *ptr = (unsigned char*)str.data;
7590 const unsigned char *end = ptr + str.size;
7595 while (end - ptr >= 3) {
7596 buf[0] = base64[ptr[0] >> 2];
7597 buf[1] = base64[((ptr[0] & 0x3) << 4) | (ptr[1] >> 4)];
7598 buf[2] = base64[((ptr[1] & 0xf) << 2) | (ptr[2] >> 6)];
7599 buf[3] = base64[ptr[2] & 0x3f];
7601 ptr += 3;
7604 switch (end - ptr) {
7606 buf[0] = base64[ptr[0] >> 2];
7607 buf[1] = base64[((ptr[0] & 0x3) << 4) | (ptr[1] >> 4)];
7608 buf[2] = base64[(ptr[1] & 0xf) << 2];
7613 buf[0] = base64[ptr[0] >> 2];
7614 buf[1] = base64[((ptr[0] & 0x3) << 4)];
7625 const char *ptr = str.data;
7626 const char *end = ptr + str.size;
7628 while (ptr < end) {
7629 switch (*ptr) {
7652 if ((uint8_t)*ptr < 0x20) {
7653 jsonenc_printf(e, "\\u%04x", (int)(uint8_t)*ptr);
7657 jsonenc_putbytes(e, ptr, 1);
7661 ptr++;
7693 const char *ptr = end;
7703 if (--ptr == type_url.data) {
7707 if (*ptr == '/') {
7708 ptr++;
7713 ret = upb_symtab_lookupmsg2(e->ext_pool, ptr, end - ptr);
7716 jsonenc_errf(e, "Couldn't find Any type: %.*s", (int)(end - ptr), ptr);
7765 const char *ptr = path.data;
7766 const char *end = ptr + path.size;
7768 while (ptr < end) {
7769 char ch = *ptr;
7774 if (ptr == end - 1 || *(ptr + 1) < 'a' || *(ptr + 1) > 'z') {
7777 ch = *++ptr - 32;
7781 ptr++;
8079 size_t ret = e->ptr - e->buf + e->overflow;
8082 if (e->ptr == e->end) e->ptr--;
8083 *e->ptr = '\0';
8095 e.ptr = buf;